@@ -1,5 +1,4 @@
 import React, { useCallback, useEffect, useRef } from "react";
-import bwipjs from "bwip-js/browser";
 import { Image as KImage, Group, Rect, Text } from "react-konva";
 import type Konva from "konva";
 import { BARCODE_1D_TYPES, ObjectRegistry } from "../../registry";
@@ -10,13 +9,10 @@ import { useFontCacheVersion } from "../../hooks/useFontCacheVersion";
 import { selectionHandlers, type KonvaObjectProps } from "./konvaObjectProps";
 import { setMeasuredBounds, clearMeasuredBounds } from "./measuredBoundsCache";
 import {
-  buildBwipOptions,
-  cleanBwipError,
   getDisplaySize,
   get1DBwipScale,
   getEanUpcHriFragments,
-  renderEanUpcRawCanvas,
-  renderTlc39Canvas,
+  renderBarcodeCanvas,
   type BarcodeDisplaySize,
   type EanUpcType,
 } from "./bwipHelpers";
@@ -91,48 +87,9 @@ export function BarcodeObject({
     !ObjectRegistry[obj.type]?.interpretationLocked &&
     !!(obj.props as { printInterpretation?: boolean }).printInterpretation;
 
-  let barcodeCanvas: HTMLCanvasElement | null = null;
-  let errorMsg: string | null = null;
-  if (obj.type === "tlc39") {
-    // bwip-js has no native tlc39 encoder, render the Code 39 + MicroPDF417
-    // composite ourselves. Goes straight to canvas, bypassing buildBwipOptions.
-    barcodeCanvas = renderTlc39Canvas(obj.props, scale, dpmm);
-    if (!barcodeCanvas) errorMsg = "TLC39 render failed";
-  } else if (EAN_UPC_TYPES.has(obj.type)) {
-    // EAN/UPC use bwip.raw + own fillRect pass so guard tails extend in
-    // the same canvas as the bars (no overlay seam). The 13-dot text
-    // zone is always reserved on the canvas so the KImage dimensions
-    // stay constant; the tails only get drawn when HRI is on.
-    const eanHeight = (obj.props as { height: number }).height;
-    const modulePxInt = get1DBwipScale(moduleWidth, scale, dpmm);
-    const barHeightPx = dotsToPx(eanHeight, scale, dpmm);
-    const tailHeightPx = dotsToPx(EAN_TEXT_ZONE_DOTS, scale, dpmm);
-    barcodeCanvas = renderEanUpcRawCanvas({
-      type: obj.type as EanUpcType,
-      text: rawContent,
-      modulePxInt,
-      barHeightPx,
-      tailHeightPx,
-      extendGuards: printInterpEnabled,
-    });
-    if (!barcodeCanvas) errorMsg = "EAN/UPC encode failed";
-  } else {
-    const opts = buildBwipOptions(obj, scale, dpmm);
-    if (opts) {
-      const canvas = document.createElement("canvas");
-      try {
-        // buildBwipOptions returns Record<string, unknown> on purpose: the
-        // option fields differ across barcode types (ean13 vs code128 vs …)
-        // and per-type narrowing would duplicate the switch already in
-        // buildBwipOptions. bwip-js' toCanvas signature uses a strict
-        // literal-string union, so the structural cast bridges the two.
-        bwipjs.toCanvas(canvas, opts as unknown as Parameters<typeof bwipjs.toCanvas>[1]);
-        barcodeCanvas = canvas;
-      } catch (e) {
-        errorMsg = cleanBwipError(e);
-      }
-    }
-  }
+  // Shared with the preflight encode check (barcodeEncodeFindings) so the
+  // displayed placeholder and the badge can't disagree on what's codable.
+  const { canvas: barcodeCanvas, error: errorMsg } = renderBarcodeCanvas(obj, scale, dpmm);
 
   // Single object holding the full ZPL footprint (w/h) and the bar
   // sub-rectangle (barW/barH/barLeftPx/barTopPx). Defaults zero out
 
@@ -24,6 +24,7 @@ import { computeAlignDeltas, computeDistribute, computeTidy } from "../../lib/al
 import type { AlignOp, AlignBox, DistributeAxis, AlignRef } from "../../lib/align";
 import { objectBoundsDots, selectionUnionDots, printableRectDots } from "../../lib/objectBounds";
 import { computePreflight } from "../../lib/preflight";
+import { barcodeEncodeFindings } from "./barcodePreflight";
 import { rotateSelectionChanges } from "../../lib/groupRotation";
 import { selectTidyTargets } from "../../lib/tidyClassify";
 import { safeAreaRectDots } from "../../lib/safeArea";
@@ -503,7 +504,12 @@ export const LabelCanvas = forwardRef<LabelCanvasHandle, Props>(function LabelCa
   // during drag/preview-lock like the rest of the chrome.
   const preflightSuppressed = previewLocks || isDragging;
   const preflightLeaves = preflightSuppressed ? [] : exportableLeaves(objects);
-  const preflightFindings = preflightSuppressed ? [] : computePreflight(preflightLeaves, frameCtx);
+  const preflightFindings = preflightSuppressed
+    ? []
+    : [
+        ...computePreflight(preflightLeaves, frameCtx),
+        ...barcodeEncodeFindings(preflightLeaves, scale, label.dpmm),
+      ];
   // Off-label marks pair each off-label finding with its on-screen bbox: a
   // clipped object gets a solid amber outline, a fully-outside one a dashed red
   // outline with a faint fill. Keyed on the off-label kind (not severity) so a
 
@@ -35,6 +35,11 @@ export function PreflightOverlay({ findings, objects, onSelect }: Props) {
   const kindText: Record<PreflightKind, string> = {
     offLabelOutside: t.preflight.offLabelOutside,
     offLabelClipped: t.preflight.offLabelClipped,
+    renderFailed: t.preflight.renderFailed,
+    blockTooNarrow: t.preflight.blockTooNarrow,
+    barcodeTooSmall: t.preflight.barcodeTooSmall,
+    textOverset: t.preflight.textOverset,
+    imageMissing: t.preflight.imageMissing,
   };
   const nameOf = (id: string) => {
     const o = byId.get(id);
@@ -73,14 +78,18 @@ export function PreflightOverlay({ findings, objects, onSelect }: Props) {
                   key={`${f.objectId}-${i}`}
                   type="button"
                   role="menuitem"
+                  title={f.detail || undefined}
                   onClick={() => {
                     onSelect(f.objectId);
                     setOpen(false);
                   }}
                   className="flex items-center gap-2 px-3 py-1.5 text-xs text-left hover:bg-surface-2 transition-colors"
                 >
                   <Icon className={`w-3.5 h-3.5 shrink-0 ${tone}`} />
-                  <span className="truncate text-text">{nameOf(f.objectId)}</span>
+                  <span className="flex flex-col min-w-0">
+                    <span className="truncate text-text">{nameOf(f.objectId)}</span>
+                    {f.detail && <span className="truncate text-[10px] text-muted">{f.detail}</span>}
+                  </span>
                   <span className="ml-auto shrink-0 text-muted">{kindText[f.kind]}</span>
                 </button>
               );
 
@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import { barcodeEncodeFindings } from "./barcodePreflight";
+import type { LabelObject } from "../../types/Group";
+import type { LeafObject } from "../../registry";
+
+const bar = (id: string): LeafObject =>
+  ({ id, type: "code128", x: 0, y: 0, rotation: 0,
+     props: { content: "X", height: 50, moduleWidth: 2, printInterpretation: false, checkDigit: false, rotation: "N" } } as LabelObject as LeafObject);
+
+describe("barcodeEncodeFindings", () => {
+  it("maps an encode error to a renderFailed finding over all given leaves", () => {
+    const leaves = [bar("a"), bar("b")];
+    // Inject the encoder so the mapping is tested without the DOM bwip encoder;
+    // this also proves a hidden-but-exported leaf is checked (no visibility gate).
+    const out = barcodeEncodeFindings(leaves, 1, 8, (l) => (l.id === "a" ? "too much data" : null));
+    expect(out).toEqual([
+      { objectId: "a", kind: "renderFailed", severity: "error", detail: "too much data" },
+    ]);
+  });
+
+  it("returns nothing when every leaf encodes", () => {
+    expect(barcodeEncodeFindings([bar("a")], 1, 8, () => null)).toEqual([]);
+  });
+});
@@ -0,0 +1,36 @@
+import type { LeafObject } from "../../registry";
+import { PREFLIGHT_SEVERITY, type PreflightFinding } from "../../lib/preflight";
+import { renderBarcodeCanvas } from "./bwipHelpers";
+
+// Cache the encode verdict per object identity. The store is identity-preserving,
+// so an unedited barcode keeps its reference and is not re-encoded when a
+// sibling changes (editing one object would otherwise re-encode the whole page).
+const encodeCache = new WeakMap<LeafObject, { scale: number; dpmm: number; error: string | null }>();
+
+function cachedEncodeError(leaf: LeafObject, scale: number, dpmm: number): string | null {
+  const hit = encodeCache.get(leaf);
+  if (hit && hit.scale === scale && hit.dpmm === dpmm) return hit.error;
+  const error = renderBarcodeCanvas(leaf, scale, dpmm).error;
+  encodeCache.set(leaf, { scale, dpmm, error });
+  return error;
+}
+
+/** Encode check over ALL exportable leaves, not just rendered ones, so a
+ *  hidden-but-exported barcode with an uncodable payload (QR overflow, invalid
+ *  EAN, ...) still badges. Lives at the canvas layer because the encoder does.
+ *  `encodeError` is injectable so the mapping is testable without the encoder. */
+export function barcodeEncodeFindings(
+  leaves: readonly LeafObject[],
+  scale: number,
+  dpmm: number,
+  encodeError: (leaf: LeafObject) => string | null = (leaf) => cachedEncodeError(leaf, scale, dpmm),
+): PreflightFinding[] {
+  const findings: PreflightFinding[] = [];
+  for (const leaf of leaves) {
+    const error = encodeError(leaf);
+    if (error) {
+      findings.push({ objectId: leaf.id, kind: "renderFailed", severity: PREFLIGHT_SEVERITY.renderFailed, detail: error });
+    }
+  }
+  return findings;
+}
@@ -2,7 +2,7 @@
 // canvas. Per-symbology rationale lives at each case in getUprightDisplaySize.
 
 import bwipjs from "bwip-js/browser";
-import { type LeafObject } from "../../registry";
+import { getEntry, type LeafObject } from "../../registry";
 import { barcodeTextZoneDots, barcodeZoneAbove } from "../../lib/barcodeHri";
 import { upceData6FromFd } from "../../registry/hriFormatters";
 import type { LabelObject } from "../../types/Group";
@@ -20,6 +20,7 @@ import {
   CODE11_QUIET_ZONE_DELTA_MODULES,
   CODE93_QUIET_ZONE_DELTA_MODULES,
   EAN_TEXT_ZONE_DOTS,
+  EAN_UPC_TYPES,
   GS1_DATABAR_PADDING_ROWS,
   GS1_DATABAR_SPEC_HEIGHT_MODULES,
   LOGMARS_TEXT_ZONE_DOTS,
@@ -959,3 +960,42 @@ export function renderTlc39Canvas(
   ctx.drawImage(code39Src, 0, mpdfPxH, w, code39PxH);
   return composite;
 }
+
+/** Single source for encoding an object as a barcode at `scale`: used by the
+ *  canvas display AND the preflight encode check. Returns the rendered canvas
+ *  (null on failure) and a cleaned error message (null on success). A
+ *  non-barcode type yields {canvas:null, error:null}. */
+export function renderBarcodeCanvas(
+  obj: LeafObject,
+  scale: number,
+  dpmm: number,
+): { canvas: HTMLCanvasElement | null; error: string | null } {
+  if (obj.type === "tlc39") {
+    const canvas = renderTlc39Canvas(obj.props as Parameters<typeof renderTlc39Canvas>[0], scale, dpmm);
+    return { canvas, error: canvas ? null : "TLC39 render failed" };
+  }
+  if (EAN_UPC_TYPES.has(obj.type)) {
+    const moduleWidth = (obj.props as { moduleWidth?: number }).moduleWidth ?? 2;
+    const printInterpEnabled =
+      !getEntry(obj.type)?.interpretationLocked &&
+      !!(obj.props as { printInterpretation?: boolean }).printInterpretation;
+    const canvas = renderEanUpcRawCanvas({
+      type: obj.type as EanUpcType,
+      text: (obj.props as { content?: string }).content ?? "",
+      modulePxInt: get1DBwipScale(moduleWidth, scale, dpmm),
+      barHeightPx: dotsToPx((obj.props as { height: number }).height, scale, dpmm),
+      tailHeightPx: dotsToPx(EAN_TEXT_ZONE_DOTS, scale, dpmm),
+      extendGuards: printInterpEnabled,
+    });
+    return { canvas, error: canvas ? null : "EAN/UPC encode failed" };
+  }
+  const opts = buildBwipOptions(obj, scale, dpmm);
+  if (!opts) return { canvas: null, error: null };
+  const canvas = document.createElement("canvas");
+  try {
+    bwipjs.toCanvas(canvas, opts as unknown as Parameters<typeof bwipjs.toCanvas>[1]);
+    return { canvas, error: null };
+  } catch (e) {
+    return { canvas: null, error: cleanBwipError(e) };
+  }
+}
@@ -0,0 +1,23 @@
+import type { PreflightCtx, PreflightProducerResult } from "../types/preflight";
+
+/** Recommended minimum barcode module / X-dimension in mm for reliable general
+ *  scanning, per GS1/AIM guidance (~0.25 mm). Below this the preflight warns.
+ *  Shared floor for 1D X-dimension and 2D cell size. */
+export const MIN_BARCODE_MODULE_MM = 0.25;
+
+/** A `barcodeTooSmall` finding when the module size (dots) is below the minimum
+ *  scannable X-dimension at the device density. Used by every 1D and 2D type. */
+export function moduleTooSmallFindings(moduleDots: number, dpmm: number): PreflightProducerResult[] {
+  const mm = moduleDots / dpmm;
+  if (!(mm < MIN_BARCODE_MODULE_MM)) return []; // also short-circuits NaN/Infinity
+  return [{ kind: "barcodeTooSmall", detail: `${mm.toFixed(2)} mm (min ${MIN_BARCODE_MODULE_MM} mm)` }];
+}
+
+/** Curried registry `preflight` producer: warns when the named module-size prop
+ *  (e.g. moduleWidth, magnification, dimension) is below the min X-dimension.
+ *  One source for the scannability check every 1D/2D barcode type registers. */
+export function moduleTooSmallPreflight<P extends object>(
+  prop: keyof P & string,
+): (obj: { props: P }, ctx: PreflightCtx) => PreflightProducerResult[] {
+  return (obj, ctx) => moduleTooSmallFindings(obj.props[prop] as number, ctx.label.dpmm);
+}
@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { computePreflight } from "./preflight";
+import { getEntry } from "../registry";
 import type { ObjectBoundsCtx } from "./objectBounds";
 import type { LabelObject } from "../types/Group";
 import type { LeafObject } from "../registry";
@@ -117,3 +118,77 @@ describe("computePreflight (off-label producer)", () => {
     ]);
   });
 });
+
+describe("per-type producers (registry preflight capability)", () => {
+  const textLeaf = (props: object): LeafObject =>
+    ({ id: "t", type: "text", x: 0, y: 0, rotation: 0, props } as LabelObject as LeafObject);
+  const bar = (moduleWidth: number): LeafObject =>
+    ({
+      id: "bc", type: "code128", x: 100, y: 100, rotation: 0,
+      props: { content: "X", height: 50, moduleWidth, printInterpretation: false, checkDigit: false, rotation: "N" },
+    } as LabelObject as LeafObject);
+
+  it("text: a block narrower than one glyph cell flags blockTooNarrow", () => {
+    const narrow = getEntry("text")!.preflight!(textLeaf({ content: "X", fontHeight: 30, fontWidth: 0, blockWidth: 2 }), { label });
+    expect(narrow).toEqual([{ kind: "blockTooNarrow" }]);
+  });
+
+  it("text: a wide block and a plain (normal) field flag nothing", () => {
+    const wide = getEntry("text")!.preflight!(textLeaf({ content: "X", fontHeight: 30, fontWidth: 0, blockWidth: 200 }), { label });
+    const normal = getEntry("text")!.preflight!(textLeaf({ content: "X", fontHeight: 30, fontWidth: 0 }), { label });
+    expect(wide).toEqual([]);
+    expect(normal).toEqual([]);
+  });
+
+  it("barcode: a module below the min X-dimension flags barcodeTooSmall", () => {
+    // moduleWidth 1 @ 8 dpmm = 0.125 mm < 0.25 mm.
+    const small = getEntry("code128")!.preflight!(bar(1), { label });
+    expect(small).toEqual([{ kind: "barcodeTooSmall", detail: "0.13 mm (min 0.25 mm)" }]);
+  });
+
+  it("barcode: a module at/above the min X-dimension flags nothing", () => {
+    // moduleWidth 2 @ 8 dpmm = 0.25 mm.
+    expect(getEntry("code128")!.preflight!(bar(2), { label })).toEqual([]);
+  });
+
+  it("computePreflight stamps objectId + severity from a producer finding", () => {
+    expect(computePreflight([bar(1)], ctx)).toContainEqual({
+      objectId: "bc", kind: "barcodeTooSmall", severity: "warning", detail: "0.13 mm (min 0.25 mm)",
+    });
+  });
+
+  it("2D: a QR magnification below the min cell size flags barcodeTooSmall", () => {
+    const qr = (magnification: number): LeafObject =>
+      ({ id: "q", type: "qrcode", x: 0, y: 0, rotation: 0,
+         props: { content: "x", magnification, errorCorrection: "Q", model: 2, rotation: "N" } } as LabelObject as LeafObject);
+    // magnification 1 @ 8 dpmm = 0.125 mm < 0.25; magnification 2 = 0.25 mm (ok).
+    expect(getEntry("qrcode")!.preflight!(qr(1), { label })).toEqual([
+      { kind: "barcodeTooSmall", detail: "0.13 mm (min 0.25 mm)" },
+    ]);
+    expect(getEntry("qrcode")!.preflight!(qr(2), { label })).toEqual([]);
+  });
+
+  it("text: ^FB content wrapping past the line cap flags textOverset", () => {
+    const fb = textLeaf({ content: "AAA BBB CCC", fontHeight: 30, fontWidth: 0, blockWidth: 40, blockLines: 1 });
+    expect(getEntry("text")!.preflight!(fb, { label })).toEqual([{ kind: "textOverset" }]);
+  });
+
+  it("text: ^TB content taller than the block height flags textOverset", () => {
+    const tb = textLeaf({ content: "AAA", fontHeight: 30, fontWidth: 0, blockWidth: 200, blockHeight: 10, textMode: "tb" });
+    expect(getEntry("text")!.preflight!(tb, { label })).toEqual([{ kind: "textOverset" }]);
+  });
+
+  it("text: a block with room to spare flags nothing", () => {
+    const ok = textLeaf({ content: "AAA", fontHeight: 30, fontWidth: 0, blockWidth: 400, blockLines: 5 });
+    expect(getEntry("text")!.preflight!(ok, { label })).toEqual([]);
+  });
+
+  it("image: no resolvable bytes flags imageMissing; rawGf resolves", () => {
+    const img = (props: object): LeafObject =>
+      ({ id: "i", type: "image", x: 0, y: 0, rotation: 0, props } as LabelObject as LeafObject);
+    expect(getEntry("image")!.preflight!(img({ imageId: "nope", widthDots: 200, threshold: 128 }), { label })).toEqual([
+      { kind: "imageMissing" },
+    ]);
+    expect(getEntry("image")!.preflight!(img({ imageId: "nope", widthDots: 200, threshold: 128, rawGf: "^GFA,1,1,1,00" }), { label })).toEqual([]);
+  });
+});