@@ -14,6 +14,7 @@ import { isDesktopShell } from "../../lib/platform";
 import { getPrinterAddress, setPrinterAddress } from "../../lib/printerAddress";
 import { listLocalPrinters, sendZplLocal, isLikelyZebra, type LocalPrinter } from "../../lib/localPrint";
 import { sendZplUsb, setupUsbAccess, isLikelyZebra as isUsbZebra } from "../../lib/usbPrint";
+import { printerOptionLabel } from "../../lib/printerLabel";
 import { useUsbPrinters } from "../../hooks/useUsbPrinters";
 
 const LS_PRINTER_UID = "zebra_print_uid";
@@ -332,7 +333,7 @@ export function PrintToZebraDialog({ zpl, onClose }: Props) {
           ? [{ value: "", label: loadingLocal ? t.zebraPrint.discovering : t.zebraPrint.noPrinters }]
           : localPrinters.map((p) => ({
               value: p.system_name,
-              label: isLikelyZebra(p) ? `${p.name} · ZPL?` : p.name,
+              label: printerOptionLabel(p.name, isLikelyZebra(p)),
             })),
       selectDisabled: localPrinters.length === 0,
       onSend: handleLocalSend,
@@ -350,7 +351,7 @@ export function PrintToZebraDialog({ zpl, onClose }: Props) {
           ? [{ value: "", label: usb.loading ? t.zebraPrint.discovering : t.zebraPrint.noPrinters }]
           : usb.printers.map((p) => ({
               value: p.id,
-              label: isUsbZebra(p) ? `${p.name} · ZPL?` : p.name,
+              label: printerOptionLabel(p.name, isUsbZebra(p)),
             })),
       selectDisabled: usb.printers.length === 0,
       onSend: handleUsbSend,
 
@@ -1,7 +1,7 @@
 import { useState, useEffect } from "react";
 import { useT } from "../../hooks/useT";
 import { useLabelStore, selectEffectivePreviewProvider } from "../../store/labelStore";
-import { isDesktopShell, isMacDesktop } from "../../lib/platform";
+import { isDesktopShell } from "../../lib/platform";
 import { isDefaultHost } from "../../lib/labelary";
 import {
   getPreviewTransport,
@@ -11,6 +11,7 @@ import {
   type PreviewTransport,
 } from "../../lib/printerAddress";
 import { isLikelyZebra } from "../../lib/usbPrint";
+import { printerOptionLabel } from "../../lib/printerLabel";
 import { useUsbPrinters } from "../../hooks/useUsbPrinters";
 import { labelCls, inputCls, buttonCls } from "../ui/formStyles";
 import { Select } from "../ui/Select";
@@ -71,17 +72,19 @@ export function PreviewSettingsTab() {
     const a = getPrinterAddress();
     return { host: a.host, port: String(a.port) };
   });
-  // USB preview needs the direct interface driver, which only macOS has; on
-  // other desktops the transport stays network without offering the choice.
-  const [transport, setTransport] = useState<PreviewTransport>(() =>
-    isMacDesktop ? getPreviewTransport() : "network",
-  );
+  const [transport, setTransport] = useState<PreviewTransport>(getPreviewTransport);
   const selectTransport = (v: PreviewTransport) => {
     setTransport(v);
     setPreviewTransport(v);
   };
-  // Shared with the print dialog so both pick from the same enumerated devices.
-  const usb = useUsbPrinters(isMacDesktop);
+  // Shared with the print dialog; enumerate only when the printer provider can
+  // consume the result.
+  const usb = useUsbPrinters(isDesktopShell && provider === "printer");
+  // Unplugging every USB printer hides the transport section; render the
+  // stranded 'usb' choice as network without persisting it, so a replug
+  // restores the selection (mirrors the print dialog's stranded-tab fix).
+  const usbAvailable = usb.printers.length > 0;
+  const effectiveTransport: PreviewTransport = usbAvailable ? transport : "network";
   const persistAddress = () => {
     setPrinterAddress(address.host.trim(), address.port);
     // Snap the inputs to the validated values (host trimmed, an invalid/empty
@@ -149,27 +152,27 @@ export function PreviewSettingsTab() {
         />
       </section>
 
-      {provider === "printer" && isMacDesktop && (
+      {provider === "printer" && usbAvailable && (
         <section className="flex flex-col gap-2">
           <h3 className="font-mono text-[10px] uppercase tracking-widest text-muted">{loc.transportHeading}</h3>
           <RadioOption
             name="preview-transport"
             value="network"
-            current={transport}
+            current={effectiveTransport}
             onSelect={selectTransport}
             label={loc.transportNetwork}
           />
           <RadioOption
             name="preview-transport"
             value="usb"
-            current={transport}
+            current={effectiveTransport}
             onSelect={selectTransport}
             label={loc.transportUsb}
           />
         </section>
       )}
 
-      {provider === "printer" && isDesktopShell && transport === "network" && (
+      {provider === "printer" && isDesktopShell && effectiveTransport === "network" && (
         <section className="flex flex-col gap-2">
           <h3 className="font-mono text-[10px] uppercase tracking-widest text-muted">{loc.printerAddressHeading}</h3>
           <div className="flex gap-2 max-w-md">
@@ -201,7 +204,7 @@ export function PreviewSettingsTab() {
         </section>
       )}
 
-      {provider === "printer" && transport === "usb" && (
+      {provider === "printer" && effectiveTransport === "usb" && (
         <section className="flex flex-col gap-2">
           <h3 className="font-mono text-[10px] uppercase tracking-widest text-muted">{t.zebraPrint.printer}</h3>
           <div className="max-w-md">
@@ -215,7 +218,7 @@ export function PreviewSettingsTab() {
                     ? [{ value: "", label: usb.loading ? t.zebraPrint.discovering : t.zebraPrint.noPrinters }]
                     : usb.printers.map((p) => ({
                         value: p.id,
-                        label: isLikelyZebra(p) ? `${p.name} · ZPL?` : p.name,
+                        label: printerOptionLabel(p.name, isLikelyZebra(p)),
                       })),
               }]}
             />
 
@@ -0,0 +1,5 @@
+/** Picker label: the name, suffixed "· ZPL?" when it looks ZPL-capable so the
+ *  user can spot the Zebra among unrelated print queues. */
+export function printerOptionLabel(name: string, isZebra: boolean): string {
+  return isZebra ? `${name} · ZPL?` : name;
+}
@@ -20,6 +20,7 @@ type PrinterQueryFailure =
   | { kind: "refused" }
   | { kind: "unreachable" }
   | { kind: "not_found" }
+  | { kind: "permission_denied" }
   | { kind: "error"; message: string };
 
 export type PrinterPreviewResult = { kind: "bitmap"; bitmap: PrinterBitmap } | PrinterQueryFailure;
 
@@ -8,51 +8,59 @@ export interface UsbPrinter {
   vendor_id: string;
 }
 
+/** The invoke-rejection member shared by the USB result unions. */
+interface UsbError {
+  kind: "error";
+  message: string;
+}
+
 export type UsbPrintResult =
   | { kind: "sent" }
   | { kind: "permission_denied" }
   | { kind: "not_found" }
-  | { kind: "error"; message: string };
+  | UsbError;
+
+/** Mirrors the Rust UsbQueryResult; `error` covers the invoke rejection. */
+export type UsbQueryResult =
+  | { kind: "data"; body: string }
+  | { kind: "permission_denied" }
+  | { kind: "not_found" }
+  | UsbError;
 
 /** Hint only for sorting/labels: the Zebra USB vendor id. */
 export function isLikelyZebra(p: UsbPrinter): boolean {
   return p.vendor_id.toLowerCase() === "0a5f";
 }
 
-/** Desktop shell only; the web build and unsupported desktops (Windows) return
- *  nothing. Linux enumerates via usblp, macOS via IOKit. */
+/** Desktop shell only (web and Windows return nothing). */
 export async function listUsbPrinters(): Promise<UsbPrinter[]> {
   if (!isDesktopShell) return [];
   const { invoke } = await import("@tauri-apps/api/core");
   return await invoke<UsbPrinter[]>("list_usb_printers");
 }
 
-export async function sendZplUsb(id: string, zpl: string): Promise<UsbPrintResult> {
+/** Desktop guard + lazy Tauri import; a rejection folds into the union's
+ *  `error` member. */
+async function invokeUsbCommand<R>(
+  cmd: string,
+  args: Record<string, unknown>,
+): Promise<R | UsbError> {
   if (!isDesktopShell) return { kind: "error", message: "USB printing requires the desktop app" };
   const { invoke } = await import("@tauri-apps/api/core");
   try {
-    return await invoke<UsbPrintResult>("send_zpl_usb", { device: id, zpl });
+    return await invoke<R>(cmd, args);
   } catch (e) {
     return { kind: "error", message: errorMessage(e) };
   }
 }
 
-/** Mirrors the Rust UsbQueryResult; `error` covers the invoke rejection. */
-export type UsbQueryResult =
-  | { kind: "data"; body: string }
-  | { kind: "not_found" }
-  | { kind: "error"; message: string };
+export function sendZplUsb(id: string, zpl: string): Promise<UsbPrintResult> {
+  return invokeUsbCommand<UsbPrintResult>("send_zpl_usb", { device: id, zpl });
+}
 
-/** Send ZPL and read the printer's reply over the bulk-in endpoint (macOS
- *  only; the Linux usblp transport has no read side wired up). */
-export async function queryZplUsb(id: string, zpl: string): Promise<UsbQueryResult> {
-  if (!isDesktopShell) return { kind: "error", message: "USB printing requires the desktop app" };
-  const { invoke } = await import("@tauri-apps/api/core");
-  try {
-    return await invoke<UsbQueryResult>("query_zpl_usb", { device: id, zpl });
-  } catch (e) {
-    return { kind: "error", message: errorMessage(e) };
-  }
+/** Send ZPL and read the printer's reply. Desktop transports only. */
+export function queryZplUsb(id: string, zpl: string): Promise<UsbQueryResult> {
+  return invokeUsbCommand<UsbQueryResult>("query_zpl_usb", { device: id, zpl });
 }
 
 export async function setupUsbAccess(): Promise<void> {
 
@@ -8,7 +8,6 @@ import {
   type PrinterRenderDims,
 } from '../../lib/printerPreview';
 import { getPreviewTransport, getPrinterAddress, getUsbPrinterId } from '../../lib/printerAddress';
-import { isMacDesktop } from '../../lib/platform';
 import { buildActiveCsvRow } from '../../lib/variableBinding';
 import { buildPreviewZpl } from '../../lib/printPreview';
 import { currentObjects, selectEffectivePreviewProvider, selectLabelaryEndpoint } from '../labelStore.selectors';
@@ -52,22 +51,19 @@ const previewCache = (() => {
 export const __resetPreviewCacheForTests = (): void => previewCache._resetForTests();
 
 /** The configured preview target, or the message telling the user what to
- *  configure. USB and network live in separate settings so an incomplete one
- *  never silently falls back to the other. */
+ *  configure. */
 function resolvePreviewTarget(): { target: PreviewTarget } | { error: string } {
-  // USB query is macOS-only, and the settings UI only offers it there; gate the
-  // same way so a persisted 'usb' choice carried onto another OS falls back to
-  // the network address instead of routing to a command that always errors.
-  if (isMacDesktop && getPreviewTransport() === 'usb') {
+  // Keep a persisted 'usb' choice even if the device is gone: enterPreviewMode
+  // falls back to network at fetch time, so a re-plug restores it. An empty
+  // selection falls through to network.
+  if (getPreviewTransport() === 'usb') {
     const id = getUsbPrinterId();
-    return id
-      ? { target: { kind: 'usb', id } }
-      : { error: 'No USB printer selected. Pick one under Settings, Preview.' };
+    if (id) return { target: { kind: 'usb', id } };
   }
   const { host, port } = getPrinterAddress();
   return host
     ? { target: { kind: 'network', host, port } }
-    : { error: 'No printer address configured. Set the IP under Settings, Preview.' };
+    : { error: 'No printer configured. Set a USB device or IP under Settings, Preview.' };
 }
 
 /** Cache-key part identifying the device, so switching the preview transport
@@ -78,8 +74,7 @@ function previewTargetKey(target: PreviewTarget): string {
 
 export interface PreviewSlice {
   previewMode: PreviewMode;
-  /** Render current page → fetch → set status. Caller-checked: only
-   *  call when `previewMode.status` is `idle` or `error`. */
+  /** Caller-checked: only call when `previewMode.status` is `idle` or `error`. */
   enterPreviewMode: () => Promise<void>;
   /** Reset to `idle`; blob URL stays cached for re-toggle. */
   exitPreviewMode: () => void;
@@ -122,14 +117,16 @@ export const createPreviewSlice: StateCreator<LabelState, [], [], PreviewSlice>
     // render; the printer path folds the target in instead. NUL-joined so a ':'
     // inside any field can't shift a boundary and collide.
     const endpoint = selectLabelaryEndpoint(state);
+    const printerKey = (t: PreviewTarget): string => [provider, previewTargetKey(t), zpl].join('\0');
+    const serveCached = (k: string): boolean => {
+      const hit = previewCache.get(k);
+      if (hit) set({ previewMode: { status: 'active', ...hit } });
+      return hit !== null;
+    };
     const cacheKey = printerTarget
-      ? [provider, previewTargetKey(printerTarget), zpl].join('\0')
+      ? printerKey(printerTarget)
       : [provider, endpoint.host, endpoint.apiKey ?? '', zpl].join('\0');
-    const cached = previewCache.get(cacheKey);
-    if (cached !== null) {
-      set({ previewMode: { status: 'active', ...cached } });
-      return;
-    }
+    if (serveCached(cacheKey)) return;
     set({ previewMode: { status: 'loading' } });
     // Stale-request guard: status check catches an exit mid-fetch; the
     // reference-equality check catches re-entry with a different design
@@ -147,8 +144,22 @@ export const createPreviewSlice: StateCreator<LabelState, [], [], PreviewSlice>
       const fail = (error: string): void => {
         if (!isStale()) set({ previewMode: { status: 'error', error } });
       };
-      const result = await fetchPrinterPreview(printerTarget, zpl);
+      let target = printerTarget;
+      let key = cacheKey;
+      let result = await fetchPrinterPreview(target, zpl);
       if (isStale()) return;
+      // USB device gone: preview over network without touching the persisted
+      // USB choice (resolvePreviewTarget explains why).
+      if (target.kind === 'usb' && result.kind === 'not_found') {
+        const net = getPrinterAddress();
+        if (net.host) {
+          target = { kind: 'network', host: net.host, port: net.port };
+          key = printerKey(target);
+          if (serveCached(key)) return;
+          result = await fetchPrinterPreview(target, zpl);
+          if (isStale()) return;
+        }
+      }
       switch (result.kind) {
         case 'bitmap': {
           const url = bitmapToDataUrl(result.bitmap);
@@ -160,16 +171,15 @@ export const createPreviewSlice: StateCreator<LabelState, [], [], PreviewSlice>
             url,
             printerDims: printerRenderDims(result.bitmap),
           };
-          previewCache.set(cacheKey, render);
+          previewCache.set(key, render);
           set({ previewMode: { status: 'active', ...render } });
           return;
         }
         case 'refused': {
-          // 'refused' only arises from the network transport (USB has no such
-          // kind), so the port hint is appended whenever a network target is
-          // present rather than duplicated into an unreachable USB message.
+          // 'refused' is network-only (USB has no such kind), so gate the port
+          // hint on a network target.
           const hint =
-            printerTarget.kind === 'network' ? ` Check that port ${printerTarget.port} is open.` : '';
+            target.kind === 'network' ? ` Check that port ${target.port} is open.` : '';
           fail(`The printer refused the connection.${hint}`);
           return;
         }
@@ -179,6 +189,9 @@ export const createPreviewSlice: StateCreator<LabelState, [], [], PreviewSlice>
         case 'not_found':
           fail('USB printer not found. Re-plug it and check Settings, Preview.');
           return;
+        case 'permission_denied':
+          fail('No access to the USB printer. Grant it in the print dialog, USB tab.');
+          return;
         case 'error':
           fail(result.message);
           return;