diff --git a/.gitignore b/.gitignore
index 37613dc5..4258aa9c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,6 +26,7 @@ coverage/
 # Test output
 tests/fixtures/__diffs__/
 tests/fixtures/__shape_diffs__/
+tests/fixtures/__text_diffs__/
 
 # Editor directories and files
 .vscode/*
@@ -51,6 +52,4 @@ tests/fixtures/__shape_diffs__/
 .aider.conf.yml
 *.instructions.*
 
-!tests/fixtures/labelary_images/*.png
-!tests/fixtures/labelary_shape_images/*.png
 CLAUDE.md
diff --git a/index.html b/index.html
index 35010f95..dc7e4791 100644
--- a/index.html
+++ b/index.html
@@ -7,7 +7,7 @@
     <title>ZebraPrintLab</title>
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-    <link href="https://fonts.googleapis.com/css2?family=Roboto+Condensed:wght@700&family=IBM+Plex+Mono:wght@400;500&family=IBM+Plex+Sans:wght@400;500;600&display=swap" rel="stylesheet" />
+    <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500&family=IBM+Plex+Sans:wght@400;500;600&display=swap" rel="stylesheet" />
     <script>
       // Set data-theme before first paint so the user's persisted preference
       // applies before React mounts. Without this, a light-theme user sees
diff --git a/src/assets/fonts/LICENSE-APACHE-2.0.txt b/src/assets/fonts/LICENSE-APACHE-2.0.txt
new file mode 100644
index 00000000..d6456956
--- /dev/null
+++ b/src/assets/fonts/LICENSE-APACHE-2.0.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/src/assets/fonts/NOTICE.md b/src/assets/fonts/NOTICE.md
new file mode 100644
index 00000000..a1ce4cb3
--- /dev/null
+++ b/src/assets/fonts/NOTICE.md
@@ -0,0 +1,27 @@
+# PrintLab ZPL Bold
+
+PrintLab ZPL Bold is a derivative work of Roboto Condensed by
+Christian Robertson, distributed by Google Fonts under the Apache
+License, Version 2.0.
+
+## Modifications
+
+Relative to upstream Roboto Condensed:
+
+- Built from the `wght=900` instance of the variable font.
+- Per-glyph horizontal advance widths (`hmtx`) and outlines scaled
+  individually to match the metrics of Zebra firmware's CG Triumvirate
+  Condensed Bold, so layout positions agree with ZPL `^A0` rendering.
+- Vertical outlines scaled to align cap heights with the same target.
+- TrueType hinting tables (`prep`, `fpgm`, `cvt`) removed so the
+  modified outlines render unhinted.
+- Family and PostScript names renamed from "Roboto Condensed" to
+  "PrintLab ZPL".
+
+## License
+
+Apache License, Version 2.0. Full text in `LICENSE-APACHE-2.0.txt`
+next to this file, or at https://www.apache.org/licenses/LICENSE-2.0
+
+Upstream source:
+https://github.com/google/fonts/tree/main/ofl/robotocondensed
diff --git a/src/assets/fonts/PrintLabZPL-Bold.ttf b/src/assets/fonts/PrintLabZPL-Bold.ttf
new file mode 100644
index 00000000..20766543
Binary files /dev/null and b/src/assets/fonts/PrintLabZPL-Bold.ttf differ
diff --git a/src/assets/fonts/PrintLabZPL-Bold.woff2 b/src/assets/fonts/PrintLabZPL-Bold.woff2
new file mode 100644
index 00000000..6e8b3985
Binary files /dev/null and b/src/assets/fonts/PrintLabZPL-Bold.woff2 differ
diff --git a/src/components/Canvas/KonvaObject.tsx b/src/components/Canvas/KonvaObject.tsx
index 4b0c41a2..ca24fce9 100644
--- a/src/components/Canvas/KonvaObject.tsx
+++ b/src/components/Canvas/KonvaObject.tsx
@@ -1,4 +1,3 @@
-import { getFontFamily } from "../../lib/fontCache";
 import { useFontCacheVersion } from "../../hooks/useFontCacheVersion";
 import { Circle, Ellipse, Group, Rect, Text } from "react-konva";
 import { BarcodeObject } from "./BarcodeObject";
@@ -8,11 +7,8 @@ import type Konva from "konva";
 import { dotsToPx, pxToDots } from "../../lib/coordinates";
 import { outlineInset } from "../../lib/shapeGeometry";
 import { useColorScheme } from "../../lib/useColorScheme";
-import {
-  objectToDisplay,
-  displayToObject,
-  ZPL_FONT_HEIGHT_TO_CSS_RATIO,
-} from "./textPositionTransforms";
+import { ZPL_FONT_HEIGHT_TO_CSS_RATIO } from "./textPositionTransforms";
+import { getTextRenderMetrics } from "./textRenderMetrics";
 import { selectionHandlers, type KonvaObjectProps } from "./konvaObjectProps";
 
 type Props = KonvaObjectProps;
@@ -124,18 +120,29 @@ function KonvaObjectInner({
   onChange,
   snap,
 }: Props) {
-  useFontCacheVersion();
+  const fontVersion = useFontCacheVersion();
   const colors = useColorScheme();
-  // For text/serial, ^FT (baseline) needs converting to Konva's top-left
-  // anchor and the rotation introduces a 15-dot alignment offset. The
-  // helper handles both; non-text types pass through unchanged.
-  const display =
-    obj.type === "text" || obj.type === "serial"
-      ? objectToDisplay(obj.x, obj.y, obj.props, obj.positionType)
-      : { x: obj.x, y: obj.y };
+  // obj.x/y is the Konva render position (top-left of the EM bbox) —
+  // identical to what every other shape stores. The ZPL anchor (^FO
+  // cap-top / ^FT baseline) lives at obj.x/y + zplAnchorDelta and is
+  // applied only at the I/O boundary by zplGenerator / zplParser, so
+  // every in-editor interaction (drag, resize, snap, smart-align) sees
+  // a shape-agnostic single coordinate system.
+  const baseMetrics = getTextRenderMetrics(obj);
+  const textMetrics =
+    baseMetrics && (obj.type === "text" || obj.type === "serial")
+      ? {
+          ...baseMetrics,
+          fontSizePx: Math.max(
+            dotsToPx(obj.props.fontHeight, scale, dpmm) /
+              ZPL_FONT_HEIGHT_TO_CSS_RATIO,
+            6,
+          ),
+        }
+      : null;
 
-  const x = offsetX + dotsToPx(display.x, scale, dpmm);
-  const y = offsetY + dotsToPx(display.y, scale, dpmm);
+  const x = offsetX + dotsToPx(obj.x, scale, dpmm);
+  const y = offsetY + dotsToPx(obj.y, scale, dpmm);
 
   // Snap a stage-position to the nearest grid point, returns stage-position.
   const snapPos = (stageX: number, stageY: number) => ({
@@ -152,31 +159,15 @@ function KonvaObjectInner({
   };
 
   const handleDragEnd = (e: Konva.KonvaEventObject<DragEvent>) => {
-    const draggedX = pxToDots(e.target.x() - offsetX, scale, dpmm);
-    const draggedY = pxToDots(e.target.y() - offsetY, scale, dpmm);
-    // Inverse of the FT/rotation correction applied at render: without
-    // it, drag would save the Konva top-left position instead of the
-    // ZPL coordinate and re-render would jump.
-    const final =
-      obj.type === "text" || obj.type === "serial"
-        ? displayToObject(draggedX, draggedY, obj.props, obj.positionType)
-        : { x: draggedX, y: draggedY };
-
     onChange({
-      x: final.x,
-      y: final.y,
+      x: pxToDots(e.target.x() - offsetX, scale, dpmm),
+      y: pxToDots(e.target.y() - offsetY, scale, dpmm),
     });
   };
 
-  if (obj.type === "text") {
+  if ((obj.type === "text" || obj.type === "serial") && textMetrics) {
     const p = obj.props;
-    const fontSize = Math.max(
-      dotsToPx(p.fontHeight, scale, dpmm) / ZPL_FONT_HEIGHT_TO_CSS_RATIO,
-      6,
-    );
-    const fontFamily = p.printerFontName
-      ? (getFontFamily(p.printerFontName) ?? "'Roboto Condensed', sans-serif")
-      : "'Roboto Condensed', sans-serif";
+    const { content, fontFamily, fontScaleX, fontSizePx } = textMetrics;
     const zplRotationDeg: Record<typeof p.rotation, number> = {
       N: 0,
       R: 90,
@@ -184,9 +175,16 @@ function KonvaObjectInner({
       B: 270,
     };
 
-    if (p.reverse) {
-      const approxW = fontSize * p.content.length * 0.62;
-      const approxH = fontSize * 1.3;
+    if (obj.type === "text" && obj.props.reverse) {
+      // ZPL `^A0,h,w` lets `w` differ from `h` to stretch each glyph
+      // horizontally. `w=0` is Zebra shorthand for "match the height".
+      // Konva mirrors this with a scaleX on the text node: the FO anchor
+      // stays at (x, y) but the rendered glyphs occupy (w/h)·advance.
+      // Use the measured ink width (already in dot space, mirrored to
+      // CSS px via dotsToPx) so the inverted background bbox tracks the
+      // actual rendered text rather than a length-based guess.
+      const approxW = dotsToPx(textMetrics.inkWidthDots, scale, dpmm);
+      const approxH = fontSizePx * 1.3;
       return (
         <Group
           id={obj.id}
@@ -206,10 +204,16 @@ function KonvaObjectInner({
             strokeWidth={isSelected ? 1.5 : 0}
           />
           <Text
-            text={p.content}
-            fontSize={fontSize}
+            // Force re-mount on font-cache changes so Konva's internal
+            // text-width cache is dropped; otherwise a width measured
+            // before @font-face finished loading sticks and the rotated
+            // bbox lands a few dots off.
+            key={fontVersion}
+            text={content}
+            fontSize={fontSizePx}
             fontFamily={fontFamily}
             fontStyle="bold"
+            scaleX={fontScaleX}
             fill="#ffffff"
             y={approxH * 0.1}
           />
@@ -217,57 +221,40 @@ function KonvaObjectInner({
       );
     }
 
+    // Wrap in an unrotated Group with the rotated Text inside so the
+    // Konva node carrying obj.id (which the Transformer attaches to) is
+    // axis-aligned even when ZPL rotation is R/I/B. Same trick that lets
+    // box / ellipse resize cleanly: the transformer math runs on an
+    // axis-aligned bbox, with the inner rotation just changing how the
+    // glyphs paint within that bbox. Without this, Konva.Text's rotation
+    // attached directly to the transformer's node makes resize math
+    // produce drift, runaway scale, and 1e15-class numbers on commit.
     return (
-      <Text
-        id={obj.id}
-        x={x}
-        y={y}
-        text={p.content}
-        fontSize={fontSize}
-        fontFamily={fontFamily}
-        fontStyle="bold"
-        rotation={zplRotationDeg[p.rotation]}
-        fill="#000000"
-        stroke={isSelected ? colors.selection : undefined}
-        strokeWidth={isSelected ? 1 : 0}
-        draggable={!obj.locked}
-        {...selectionHandlers(onSelect)}
-        onDragMove={handleDragMove}
-        onDragEnd={handleDragEnd}
-      />
-    );
-  }
-
-  if (obj.type === "serial") {
-    const p = obj.props;
-    const fontSize = Math.max(
-      dotsToPx(p.fontHeight, scale, dpmm) / ZPL_FONT_HEIGHT_TO_CSS_RATIO,
-      6,
-    );
-    const zplRotationDeg: Record<typeof p.rotation, number> = {
-      N: 0,
-      R: 90,
-      I: 180,
-      B: 270,
-    };
-    return (
-      <Text
+      <Group
         id={obj.id}
         x={x}
         y={y}
-        text={`#${p.content}`}
-        fontSize={fontSize}
-        fontFamily="'Roboto Condensed', sans-serif"
-        fontStyle="bold"
-        rotation={zplRotationDeg[p.rotation]}
-        fill="#000000"
-        stroke={isSelected ? colors.selection : undefined}
-        strokeWidth={isSelected ? 1 : 0}
         draggable={!obj.locked}
         {...selectionHandlers(onSelect)}
         onDragMove={handleDragMove}
         onDragEnd={handleDragEnd}
-      />
+      >
+        <Text
+          // See note above re fontVersion + Konva's text-width cache.
+          key={fontVersion}
+          x={0}
+          y={0}
+          text={content}
+          fontSize={fontSizePx}
+          fontFamily={fontFamily}
+          fontStyle="bold"
+          scaleX={fontScaleX}
+          rotation={zplRotationDeg[p.rotation]}
+          fill="#000000"
+          stroke={isSelected ? colors.selection : undefined}
+          strokeWidth={isSelected ? 1 : 0}
+        />
+      </Group>
     );
   }
 
diff --git a/src/components/Canvas/LabelCanvas.tsx b/src/components/Canvas/LabelCanvas.tsx
index 2fb91ca8..45ece4a1 100644
--- a/src/components/Canvas/LabelCanvas.tsx
+++ b/src/components/Canvas/LabelCanvas.tsx
@@ -496,6 +496,11 @@ export const LabelCanvas = forwardRef<LabelCanvasHandle, Props>(function LabelCa
     // the drag at full frame rate; React state is kept in sync so a
     // subsequent re-render (selection change, scale, etc.) starts from
     // the latest position instead of snapping back.
+    //
+    // Listeners attach to the node itself, not to the stage: Konva's
+    // `transform` event (fired per-frame during a resize) does NOT
+    // bubble, so a stage-level listener would only catch `dragmove`
+    // and the button would freeze in place until the user released.
     const update = () => {
       const rect = node.getClientRect({ relativeTo: stage, skipStroke: true });
       const x = rect.x + rect.width + ROTATE_BUTTON_GAP_PX;
@@ -504,9 +509,9 @@ export const LabelCanvas = forwardRef<LabelCanvasHandle, Props>(function LabelCa
       setRotationBtnPos({ x, y });
     };
     update();
-    stage.on("dragmove.rotbtn transform.rotbtn", update);
+    node.on("dragmove.rotbtn transform.rotbtn", update);
     return () => {
-      stage.off("dragmove.rotbtn transform.rotbtn");
+      node.off("dragmove.rotbtn transform.rotbtn");
     };
   }, [singleSelected, stepRotation, scale, viewRotation]);
 
diff --git a/src/components/Canvas/hooks/useKonvaTransformer.ts b/src/components/Canvas/hooks/useKonvaTransformer.ts
index e0c7f7fb..0eacca70 100644
--- a/src/components/Canvas/hooks/useKonvaTransformer.ts
+++ b/src/components/Canvas/hooks/useKonvaTransformer.ts
@@ -14,7 +14,10 @@ import {
   forceSquareBox,
   type BoundingBox,
 } from "../transformerGeometry";
-import { modelPositionFromRenderedTopLeft } from "../transformPosition";
+import {
+  modelPositionFromRenderedTopLeft,
+  renderedTopLeftFromModel,
+} from "../transformPosition";
 import {
   computeResizeSnap,
   deriveActiveEdges,
@@ -330,20 +333,26 @@ export function useKonvaTransformer({
       obj.positionType === "FT" && BARCODE_1D_TYPES.has(obj.type)
         ? Math.max(1, snap(Math.round((obj.props as { height: number }).height * sy)))
         : undefined;
-    // Invert per-type render offsets (e.g. QR's hardcoded +10 dot Y) so the
-    // stored model position matches what BarcodeObject.handleDragEnd produces.
+    // Invert per-type render offsets (e.g. QR's hardcoded +10 dot Y) so
+    // the stored model position matches what each per-type
+    // handleDragEnd / render path produces. Text/serial render at
+    // obj.x/y directly, so they pass through unchanged.
     const modelPos = modelPositionFromRenderedTopLeft(
       obj,
       renderedXDots,
       renderedYDots,
       newBarHeightDots,
     );
-    // Only apply snap when the resize actually moved the position
-    // (e.g. dragging the top-left handle). Anchored-corner drags must keep
-    // the original position so off-grid shapes don't snap as a side-effect.
+    // Only apply snap when the resize actually moved the anchor handle.
+    // Compare in *rendered* space — for types whose render path applies
+    // a shift (text, QR, FT barcodes), comparing the rendered top-left
+    // to obj.x/y directly always trips (shift ≠ 0 in baseline), so snap
+    // fires on every anchored-corner resize and pulls the visible
+    // corner to a grid point the user didn't ask for.
+    const oldRendered = renderedTopLeftFromModel(obj);
     const pos = {
-      x: positionDidMove(modelPos.x, obj.x) ? snap(modelPos.x) : obj.x,
-      y: positionDidMove(modelPos.y, obj.y) ? snap(modelPos.y) : obj.y,
+      x: positionDidMove(renderedXDots, oldRendered.x) ? snap(modelPos.x) : obj.x,
+      y: positionDidMove(renderedYDots, oldRendered.y) ? snap(modelPos.y) : obj.y,
     };
     const commit = ObjectRegistry[obj.type]?.commitTransform;
     if (commit) {
diff --git a/src/components/Canvas/measureTextDots.ts b/src/components/Canvas/measureTextDots.ts
new file mode 100644
index 00000000..dc36a242
--- /dev/null
+++ b/src/components/Canvas/measureTextDots.ts
@@ -0,0 +1,43 @@
+/** Browser text-width measurement. Used by the anchor-shift table for
+ *  rotation-dependent text positioning, where the I and B FO branches
+ *  need the actual rendered width rather than a length-based estimate
+ *  (off by 5-15 dots for narrow `1`/`I`/`.` or wide `@`/`W`).
+ *
+ *  The 2D context is created once and cached for the lifetime of the
+ *  page — `measureText` is fast, `createElement('canvas')` isn't.
+ *  Falls back to a length-based estimate in non-DOM environments. */
+
+let ctx: CanvasRenderingContext2D | null | undefined;
+
+function getCtx(): CanvasRenderingContext2D | null {
+  if (ctx !== undefined) return ctx;
+  if (typeof document === "undefined") {
+    ctx = null;
+    return ctx;
+  }
+  const canvas = document.createElement("canvas");
+  ctx = canvas.getContext("2d");
+  return ctx;
+}
+
+/** Returns the rendered text width in CSS px at the given fontSize.
+ *  `fontFamily` and `fontStyle` must match what Konva will use so the
+ *  measurement reflects what gets painted. */
+export function measureInkWidthPx(
+  text: string,
+  fontSize: number,
+  fontFamily: string,
+  fontStyle = "bold",
+): number {
+  if (!text) return 0;
+  const c = getCtx();
+  if (!c || typeof c.measureText !== "function") {
+    // Fallback heuristic for non-DOM contexts (unit tests of pure
+    // helpers). Roboto Condensed Bold wght=900 averages ≈ 0.62·h per
+    // glyph; good enough for round-trip tests that don't actually
+    // care about exact bbox alignment.
+    return text.length * fontSize * 0.62;
+  }
+  c.font = `${fontStyle} ${fontSize}px ${fontFamily}`;
+  return c.measureText(text).width;
+}
diff --git a/src/components/Canvas/textPositionTransforms.test.ts b/src/components/Canvas/textPositionTransforms.test.ts
index 7d7f39f1..dd5ec6e0 100644
--- a/src/components/Canvas/textPositionTransforms.test.ts
+++ b/src/components/Canvas/textPositionTransforms.test.ts
@@ -1,42 +1,94 @@
 import { describe, it, expect } from 'vitest';
-import { objectToDisplay, displayToObject } from './textPositionTransforms';
+import {
+  EM_TOP_ABOVE_CAP,
+  ZPL_FONT_HEIGHT_TO_CSS_RATIO,
+  modelToZplAnchor,
+  zplAnchorToModel,
+} from './textPositionTransforms';
 
 const ROT = ['N', 'R', 'I', 'B'] as const;
+const BIAS = 0.08;
+const H = 30;
+const W = 42;
 
-describe('text position transforms', () => {
-  describe('objectToDisplay', () => {
-    it('shifts Y up by fontHeight under FT/N', () => {
-      const r = objectToDisplay(100, 200, { fontHeight: 30, rotation: 'N' }, 'FT');
-      // FT N: dy = -fontHeight (-30); rotation offset for N is 0.
-      expect(r).toEqual({ x: 100, y: 170 });
+describe('text position transforms — model ↔ ZPL anchor', () => {
+  describe('modelToZplAnchor — FT (baseline)', () => {
+    it('shifts Y down by fontHeight - bias under FT/N', () => {
+      const r = modelToZplAnchor(100, 200, { fontHeight: H, rotation: 'N' }, 'FT');
+      expect(r.x).toBeCloseTo(100);
+      expect(r.y).toBeCloseTo(200 + H - H * BIAS);
     });
 
-    it('returns the input verbatim under FO', () => {
-      const r = objectToDisplay(100, 200, { fontHeight: 30, rotation: 'I' }, 'FO');
-      expect(r).toEqual({ x: 100, y: 200 });
+    it('shifts X left by fontHeight - bias under FT/R', () => {
+      const r = modelToZplAnchor(100, 200, { fontHeight: H, rotation: 'R' }, 'FT');
+      expect(r.x).toBeCloseTo(100 - H / ZPL_FONT_HEIGHT_TO_CSS_RATIO + H * BIAS);
+      expect(r.y).toBeCloseTo(200);
     });
 
-    it('treats undefined positionType like FO', () => {
-      const r = objectToDisplay(100, 200, { fontHeight: 30, rotation: 'N' }, undefined);
-      expect(r).toEqual({ x: 100, y: 200 });
+    it('shifts Y up by fontHeight - bias under FT/I', () => {
+      const r = modelToZplAnchor(100, 200, { fontHeight: H, rotation: 'I' }, 'FT');
+      expect(r.x).toBeCloseTo(100);
+      expect(r.y).toBeCloseTo(200 - H / ZPL_FONT_HEIGHT_TO_CSS_RATIO + H * BIAS);
+    });
+
+    it('shifts X right by fontHeight - bias under FT/B', () => {
+      const r = modelToZplAnchor(100, 200, { fontHeight: H, rotation: 'B' }, 'FT');
+      expect(r.x).toBeCloseTo(100 + H / ZPL_FONT_HEIGHT_TO_CSS_RATIO - H * BIAS);
+      expect(r.y).toBeCloseTo(200);
     });
+  });
 
-    it('applies the FT correction for I (renderedH = fontHeight / ratio)', () => {
-      const r = objectToDisplay(100, 200, { fontHeight: 30, rotation: 'I' }, 'FT');
+  describe('modelToZplAnchor — FO (cap-top)', () => {
+    it('FO/N shifts Y down by ascender padding - bias', () => {
+      const r = modelToZplAnchor(100, 200, { fontHeight: H, rotation: 'N' }, 'FO');
       expect(r.x).toBeCloseTo(100);
-      expect(r.y).toBeCloseTo(200 + 30 / 1.3);
+      expect(r.y).toBeCloseTo(200 + H * EM_TOP_ABOVE_CAP - H * BIAS);
+    });
+
+    // ^FO documents itself as the top-left of the character field regardless
+    // of rotation. After Konva's rotation the pivot lands at a different
+    // corner of the rotated bbox per rotation, so the shift must cover both
+    // the EM-padding (pad - bias) AND the full h/w jump to the actual top-
+    // left of the visible field.
+    it('FO/R shifts X left by h + (padding - bias) (no inkWidth needed)', () => {
+      const r = modelToZplAnchor(100, 200, { fontHeight: H, rotation: 'R' }, 'FO');
+      expect(r.x).toBeCloseTo(
+        100 - H / ZPL_FONT_HEIGHT_TO_CSS_RATIO - H * EM_TOP_ABOVE_CAP + H * BIAS,
+      );
+      expect(r.y).toBeCloseTo(200);
+    });
+
+    it('FO/I subtracts inkWidth on X and h + (pad - bias) on Y', () => {
+      const r = modelToZplAnchor(100, 200, { fontHeight: H, rotation: 'I' }, 'FO', W);
+      expect(r.x).toBeCloseTo(100 - W);
+      expect(r.y).toBeCloseTo(
+        200 - H / ZPL_FONT_HEIGHT_TO_CSS_RATIO - H * EM_TOP_ABOVE_CAP + H * BIAS,
+      );
+    });
+
+    it('FO/B shifts X by (pad - bias) and Y up by inkWidth', () => {
+      const r = modelToZplAnchor(100, 200, { fontHeight: H, rotation: 'B' }, 'FO', W);
+      expect(r.x).toBeCloseTo(100 + H * EM_TOP_ABOVE_CAP - H * BIAS);
+      expect(r.y).toBeCloseTo(200 - W);
+    });
+
+    it('treats undefined positionType like FO', () => {
+      const a = modelToZplAnchor(100, 200, { fontHeight: H, rotation: 'N' }, undefined);
+      const b = modelToZplAnchor(100, 200, { fontHeight: H, rotation: 'N' }, 'FO');
+      expect(a).toEqual(b);
     });
   });
 
   describe('round-trip', () => {
     for (const rotation of ROT) {
       for (const positionType of ['FO', 'FT', undefined] as const) {
-        it(`displayToObject ∘ objectToDisplay = id for ${rotation}/${positionType ?? 'undef'}`, () => {
+        it(`zplAnchorToModel ∘ modelToZplAnchor = id for ${rotation}/${positionType ?? 'undef'}`, () => {
           const props = { fontHeight: 42, rotation };
           const objX = 123;
           const objY = 456;
-          const display = objectToDisplay(objX, objY, props, positionType);
-          const back = displayToObject(display.x, display.y, props, positionType);
+          const inkWidth = 87;
+          const anchor = modelToZplAnchor(objX, objY, props, positionType, inkWidth);
+          const back = zplAnchorToModel(anchor.x, anchor.y, props, positionType, inkWidth);
           expect(back.x).toBeCloseTo(objX);
           expect(back.y).toBeCloseTo(objY);
         });
diff --git a/src/components/Canvas/textPositionTransforms.ts b/src/components/Canvas/textPositionTransforms.ts
index f6133d82..dee81270 100644
--- a/src/components/Canvas/textPositionTransforms.ts
+++ b/src/components/Canvas/textPositionTransforms.ts
@@ -1,65 +1,94 @@
-/** Pure transforms between the text/serial object's saved coordinate
- *  (what ZPL persists) and the Konva-anchor coordinate (what we paint).
+/** Pure transforms between the text/serial object's stored coordinate
+ *  (now: Konva-render position == visual bbox top-left) and the ZPL
+ *  anchor position. Used at the ZPL I/O boundary only:
+ *    - zplGenerator: obj.x/y → ZPL ^FO/^FT coordinate
+ *    - zplParser: parsed ^FO/^FT coordinate → obj.x/y
+ *  All in-editor interactions (drag, resize, snap, smart-align) operate
+ *  on obj.x/y directly with no shift between rendered position and
+ *  storage, so the interaction layer is shape-agnostic.
  *
- *  The single correction is the ^FT baseline shift: ^FT places the
- *  origin at the baseline of the first character while Konva's Text
- *  anchor sits at a different corner depending on rotation. ^FO needs
- *  no correction, so the transforms are the identity in that case.
- *
- *  `displayToObject` is the exact inverse of `objectToDisplay` so a
- *  drag-end can recover the saved coordinate from the dragged Konva
- *  position. */
+ *  The shift table maps "what Konva paints" (EM-top-left of the rotated
+ *  text node) to "where Zebra anchors the field":
+ *    - ^FO at the cap-top of the first character (inset from the EM-top
+ *      by the ascender padding)
+ *    - ^FT at the baseline of the first character
+ *  After the rotation, the cap-top / baseline reference moves to a
+ *  different edge of the rotated bbox; the per-rotation switch below
+ *  handles that. */
 
 interface TextLikeProps {
   fontHeight: number;
   rotation: "N" | "R" | "I" | "B";
 }
 
-/** Ratio between ZPL fontHeight (cap-height) and CSS/Konva fontSize
- *  (em-height) for Roboto Condensed Bold. Empirical: divide ZPL
- *  fontHeight by this to get the Konva-rendered height in dots, or to
- *  derive the Konva fontSize. Lives here because it appears in both
- *  the FT baseline math and the text/serial render paths. */
-export const ZPL_FONT_HEIGHT_TO_CSS_RATIO = 1.3;
+/** Ratio between ZPL fontHeight and the Konva fontSize that yields a
+ *  rendered glyph height close to what Zebra firmware produces. */
+export const ZPL_FONT_HEIGHT_TO_CSS_RATIO = 1.0;
+
+/** Pre-rotation distance from EM-top to cap-top as a fraction of
+ *  fontHeight. PrintLab ZPL Bold has ascender ≈ EM-box (~1.0·h) while
+ *  Zebra's CG Triumvirate cap reaches ~0.78·h. */
+export const EM_TOP_ABOVE_CAP = 0.234;
+
+/** Small additional offset applied along the text's own "down" axis to
+ *  close the residual mismatch between PrintLab's rendered cap-top and
+ *  Labelary's cap-top across both ^FO and ^FT. ≈ 0.08·fontHeight. */
+const RENDER_Y_BIAS = 0.08;
+
+/** Offset from Konva's EM-top-left (== obj.x/y) to the ZPL field
+ *  anchor (^FO cap-top or ^FT baseline), in dot space, mapped through
+ *  the rotation. Positive: ZPL anchor sits at obj + delta. */
+function zplAnchorDelta(
+  props: TextLikeProps,
+  positionType: "FO" | "FT" | undefined,
+  inkWidthDots = 0,
+): { dx: number; dy: number } {
+  const h = props.fontHeight / ZPL_FONT_HEIGHT_TO_CSS_RATIO;
+  const pad = props.fontHeight * EM_TOP_ABOVE_CAP;
+  const bias = props.fontHeight * RENDER_Y_BIAS;
+  const isFT = positionType === "FT";
+  const w = inkWidthDots;
 
-function ftBaselineDelta(props: TextLikeProps): { dx: number; dy: number } {
-  // For R/I/B the Konva anchor sits at the far end of the rendered
-  // glyph, so we use the actual rendered height. For N the anchor is
-  // at the top, so we shift up by the full ZPL fontHeight.
-  const renderedH = props.fontHeight / ZPL_FONT_HEIGHT_TO_CSS_RATIO;
+  // For each rotation, the FO offset is the ascender padding from EM-top
+  // to cap-top; the FT offset adds cap-height to land at the baseline.
+  // The bias counter-shifts the editor render so cap-tops align with
+  // Labelary's pixel-perfectly; here it gets subtracted from the ZPL
+  // delta so the printed anchor lands where the editor displays it.
   switch (props.rotation) {
-    case "N":
-      return { dx: 0, dy: -props.fontHeight };
     case "R":
-      return { dx: renderedH, dy: 0 };
+      return isFT ? { dx: -h + bias, dy: 0 } : { dx: -h - pad + bias, dy: 0 };
     case "I":
-      return { dx: 0, dy: renderedH };
+      return isFT ? { dx: 0, dy: -h + bias } : { dx: -w, dy: -h - pad + bias };
     case "B":
-      return { dx: -renderedH, dy: 0 };
+      return isFT ? { dx: h - bias, dy: 0 } : { dx: pad - bias, dy: -w };
+    case "N":
+    default:
+      // Unknown rotation values get the N treatment so malformed inputs
+      // can't propagate `undefined` through the math.
+      return isFT ? { dx: 0, dy: h - bias } : { dx: 0, dy: pad - bias };
   }
 }
 
-/** Object position → display anchor, in dot space. */
-export function objectToDisplay(
+/** obj.x/y (Konva render position) → ZPL anchor coordinate. */
+export function modelToZplAnchor(
   objectX: number,
   objectY: number,
   props: TextLikeProps,
   positionType: "FO" | "FT" | undefined,
+  inkWidthDots = 0,
 ): { x: number; y: number } {
-  if (positionType !== "FT") return { x: objectX, y: objectY };
-  const ft = ftBaselineDelta(props);
-  return { x: objectX + ft.dx, y: objectY + ft.dy };
+  const d = zplAnchorDelta(props, positionType, inkWidthDots);
+  return { x: objectX + d.dx, y: objectY + d.dy };
 }
 
-/** Inverse of objectToDisplay — recovers the saved coordinate from a
- *  display anchor (used at drag end). */
-export function displayToObject(
-  displayX: number,
-  displayY: number,
+/** ZPL anchor coordinate (parsed from ^FO/^FT) → obj.x/y storage. */
+export function zplAnchorToModel(
+  anchorX: number,
+  anchorY: number,
   props: TextLikeProps,
   positionType: "FO" | "FT" | undefined,
+  inkWidthDots = 0,
 ): { x: number; y: number } {
-  if (positionType !== "FT") return { x: displayX, y: displayY };
-  const ft = ftBaselineDelta(props);
-  return { x: displayX - ft.dx, y: displayY - ft.dy };
+  const d = zplAnchorDelta(props, positionType, inkWidthDots);
+  return { x: anchorX - d.dx, y: anchorY - d.dy };
 }
diff --git a/src/components/Canvas/textRenderMetrics.ts b/src/components/Canvas/textRenderMetrics.ts
new file mode 100644
index 00000000..be89190a
--- /dev/null
+++ b/src/components/Canvas/textRenderMetrics.ts
@@ -0,0 +1,61 @@
+import { getFontFamily } from "../../lib/fontCache";
+import type { LabelObject } from "../../types/Group";
+import { measureInkWidthPx } from "./measureTextDots";
+import { ZPL_FONT_HEIGHT_TO_CSS_RATIO } from "./textPositionTransforms";
+
+/** Shared text/serial render metrics used by every consumer of the
+ *  rendered glyph dimensions — the Konva renderer, the resize commit
+ *  path, the ZPL emit path (textFieldPos), and the ZPL parser. Single
+ *  source of truth so they all measure the same way; without that, the
+ *  inkWidth that goes into `modelToZplAnchor` at emit time would
+ *  disagree with the one at parse time and round-trips would drift on
+ *  FO/I and FO/B (the two rotations whose shift depends on text width). */
+export interface TextRenderMetrics {
+  content: string;
+  fontFamily: string;
+  fontScaleX: number;
+  inkWidthDots: number;
+}
+
+/** Raw inputs for the metrics primitive — the parser feeds these
+ *  directly because at parse time there's no `obj` yet. */
+export interface TextMetricsInput {
+  content: string;
+  fontHeight: number;
+  fontWidth: number;
+  printerFontName?: string;
+}
+
+/** Compute metrics from raw text parameters. Pure once
+ *  `measureInkWidthPx` and `getFontFamily` are pure. */
+export function computeTextRenderMetrics(input: TextMetricsInput): TextRenderMetrics {
+  const { content, fontHeight, fontWidth, printerFontName } = input;
+  const fontFamily = printerFontName
+    ? (getFontFamily(printerFontName) ?? "'PrintLab ZPL', sans-serif")
+    : "'PrintLab ZPL', sans-serif";
+  const fontScaleX = fontWidth > 0 ? fontWidth / fontHeight : 1;
+  const inkWidthDots =
+    measureInkWidthPx(
+      content,
+      fontHeight / ZPL_FONT_HEIGHT_TO_CSS_RATIO,
+      fontFamily,
+    ) * fontScaleX;
+  return { content, fontFamily, fontScaleX, inkWidthDots };
+}
+
+/** Object-shaped wrapper used by the renderer and the resize commit
+ *  path. `fontHeightOverride` lets the resize commit see the
+ *  to-be-written fontHeight before it lands in obj.props. */
+export function getTextRenderMetrics(
+  obj: LabelObject,
+  fontHeightOverride?: number,
+): TextRenderMetrics | null {
+  if (obj.type !== "text" && obj.type !== "serial") return null;
+  const p = obj.props;
+  return computeTextRenderMetrics({
+    content: obj.type === "serial" ? `#${p.content}` : p.content,
+    fontHeight: fontHeightOverride ?? p.fontHeight,
+    fontWidth: p.fontWidth,
+    printerFontName: obj.type === "text" ? obj.props.printerFontName : undefined,
+  });
+}
diff --git a/src/components/Canvas/transformPosition.ts b/src/components/Canvas/transformPosition.ts
index cbbca324..ecf7eec0 100644
--- a/src/components/Canvas/transformPosition.ts
+++ b/src/components/Canvas/transformPosition.ts
@@ -1,5 +1,5 @@
 import { BARCODE_1D_TYPES } from "../../registry";
-import type { LabelObject } from "../../types/Group";
+import type { LeafObject } from "../../registry";
 import { QR_FO_Y_OFFSET_DOTS } from "./bwipConstants";
 
 /**
@@ -15,15 +15,16 @@ import { QR_FO_Y_OFFSET_DOTS } from "./bwipConstants";
  *   commits the bar TOP as the new obj.y and the next render shifts the
  *   barcode up by another bar-height.
  *
- * Used by onTransformEnd to mirror the rendered→model conversion that
- * BarcodeObject.handleDragEnd performs for drag.
- *
- * Note: QR-FT correction is not yet implemented (the additional firmware
- * 3-module offset would need a separate code path); FT resize on QR still
- * drifts.
+ * Text/serial pass through unchanged. obj.x/y is the position of the
+ * unrotated wrapper Group around the (possibly rotated) inner Text. On
+ * resize the Konva transformer pins the opposite corner of the Group's
+ * axis-aligned clientRect — so obj.x/y naturally tracks the visible
+ * pinned corner, the ZPL anchor offset is recomputed from the new
+ * fontHeight at I/O time, and the round-trip stays exact. No inversion
+ * needed here.
  */
 export function modelPositionFromRenderedTopLeft(
-  obj: LabelObject,
+  obj: LeafObject,
   renderedXDots: number,
   renderedYDots: number,
   newBarHeightDots?: number,
@@ -40,3 +41,18 @@ export function modelPositionFromRenderedTopLeft(
   }
   return { x: renderedXDots, y: renderedYDots };
 }
+
+/** Inverse of `modelPositionFromRenderedTopLeft`: model → rendered. */
+export function renderedTopLeftFromModel(obj: LeafObject): {
+  x: number;
+  y: number;
+} {
+  if (obj.type === "qrcode" && obj.positionType !== "FT") {
+    return { x: obj.x, y: obj.y + QR_FO_Y_OFFSET_DOTS };
+  }
+  if (obj.positionType === "FT" && BARCODE_1D_TYPES.has(obj.type)) {
+    const h = (obj.props as { height: number }).height;
+    return { x: obj.x, y: obj.y - h };
+  }
+  return { x: obj.x, y: obj.y };
+}
diff --git a/src/components/Canvas/transformerGeometry.ts b/src/components/Canvas/transformerGeometry.ts
index 51bd3750..ae9ab4ad 100644
--- a/src/components/Canvas/transformerGeometry.ts
+++ b/src/components/Canvas/transformerGeometry.ts
@@ -110,6 +110,7 @@ export function applyHeightSnap(
  */
 export const POSITION_MOVE_TOLERANCE_DOTS = 1;
 
+
 export interface ActiveEdgeFlags {
   left: boolean;
   right: boolean;
diff --git a/src/hooks/useFontCacheVersion.ts b/src/hooks/useFontCacheVersion.ts
index e6ff8166..a6347ba9 100644
--- a/src/hooks/useFontCacheVersion.ts
+++ b/src/hooks/useFontCacheVersion.ts
@@ -1,9 +1,31 @@
 import { useState, useEffect } from 'react';
 import { subscribe } from '../lib/fontCache';
 
-/** Returns a version counter that increments whenever the font cache changes. */
+/** Returns a version counter that increments whenever the font cache
+ *  changes or the browser finishes loading additional @font-face fonts.
+ *  Consumers (KonvaObject) re-render so any cached `measureText` they
+ *  perform reflects the post-load glyph widths — without this the
+ *  rendered position can drift between mounts when our PrintLab font
+ *  finishes loading after first measure. */
 export function useFontCacheVersion(): number {
   const [version, setVersion] = useState(0);
-  useEffect(() => subscribe(() => setVersion(v => v + 1)), []);
+  useEffect(() => {
+    const bump = () => setVersion((v) => v + 1);
+    const unsubCache = subscribe(bump);
+
+    if (typeof document === 'undefined' || !('fonts' in document)) {
+      return unsubCache;
+    }
+
+    const onLoadingDone = () => bump();
+    document.fonts.addEventListener('loadingdone', onLoadingDone);
+    // Cover fonts that were already loading when this mounted.
+    void document.fonts.ready.then(bump);
+
+    return () => {
+      unsubCache();
+      document.fonts.removeEventListener('loadingdone', onLoadingDone);
+    };
+  }, []);
   return version;
 }
diff --git a/src/index.css b/src/index.css
index e3f8e90a..7b00dc2f 100644
--- a/src/index.css
+++ b/src/index.css
@@ -1,5 +1,19 @@
 @import "tailwindcss";
 
+/* PrintLab ZPL Bold: derivative of Roboto Condensed (Apache 2.0) whose
+   per-glyph advance widths and vertical scale were adjusted to match
+   Zebra firmware's CG Triumvirate Condensed Bold layout. Family
+   renamed per the Apache trademark clause. See
+   src/assets/fonts/NOTICE.md for the full attribution. */
+@font-face {
+  font-family: 'PrintLab ZPL';
+  src: url('./assets/fonts/PrintLabZPL-Bold.woff2') format('woff2'),
+       url('./assets/fonts/PrintLabZPL-Bold.ttf') format('truetype');
+  font-weight: 700;
+  font-style: normal;
+  font-display: swap;
+}
+
 @theme {
   --color-bg:        #141414;
   --color-surface:   #1f1f1f;
diff --git a/src/lib/zplParser.test.ts b/src/lib/zplParser.test.ts
index 1b3204d4..d946be14 100644
--- a/src/lib/zplParser.test.ts
+++ b/src/lib/zplParser.test.ts
@@ -36,8 +36,11 @@ describe('parseZPL — text via ^A0', () => {
     expect(objects).toHaveLength(1);
     const [obj] = objects;
     expect(obj?.type).toBe('text');
-    expect(obj?.x).toBe(10);
-    expect(obj?.y).toBe(20);
+    // obj.x/y is the Konva render position (EM-top-left); the parsed ^FO
+    // gives the ZPL cap-top anchor. For N/h=30 they differ by
+    // (0.234 - 0.08) * 30 = 4.62 dots in Y.
+    expect(obj?.x).toBeCloseTo(10);
+    expect(obj?.y).toBeCloseTo(20 - 4.62);
     expect(props(obj).content).toBe('Hello');
     expect(props(obj).fontHeight).toBe(30);
     expect(props(obj).rotation).toBe('N');
@@ -90,8 +93,10 @@ describe('parseZPL — text field position', () => {
 describe('parseZPL — ^LH label home offset', () => {
   it('adds ^LH offset to all field positions', () => {
     const { objects } = parseZPL('^XA^LH20,10^FO30,40^A0N,30,0^FDText^FS^XZ', 8);
-    expect(objects[0]?.x).toBe(50);  // 30 + 20
-    expect(objects[0]?.y).toBe(50);  // 40 + 10
+    // obj.x = (^FO.x + ^LH.x) - zplAnchorDelta.x; obj.y similar.
+    // For FO/N h=30: dx=0, dy=4.62.
+    expect(objects[0]?.x).toBeCloseTo(50);  // 30 + 20
+    expect(objects[0]?.y).toBeCloseTo(50 - 4.62);  // 40 + 10 - shift
   });
 });
 
@@ -634,8 +639,9 @@ describe('parseZPL — edge cases', () => {
   it('handles multiple ^FO without ^FD (bare origins are benign)', () => {
     const { objects } = parseZPL('^XA^FO10,20^FO30,40^A0N,30,0^FDText^FS^XZ', 8);
     expect(objects).toHaveLength(1);
-    expect(objects[0]?.x).toBe(30);
-    expect(objects[0]?.y).toBe(40);
+    // FO/N h=30 → obj.y = 40 - 4.62.
+    expect(objects[0]?.x).toBeCloseTo(30);
+    expect(objects[0]?.y).toBeCloseTo(40 - 4.62);
   });
 
   it('supports different dpmm values (12 dpmm / 300 DPI)', () => {
@@ -985,8 +991,8 @@ describe('parseZPL — ^FO with justification parameter', () => {
   it('parses ^FO with a 3rd parameter without errors', () => {
     const { objects } = parseZPL('^XA^FO100,200,1^A0N,30,0^FDJustified^FS^XZ', 8);
     expect(objects).toHaveLength(1);
-    expect(objects[0]?.x).toBe(100);
-    expect(objects[0]?.y).toBe(200);
+    expect(objects[0]?.x).toBeCloseTo(100);
+    expect(objects[0]?.y).toBeCloseTo(200 - 4.62);
     expect(props(objects[0]).content).toBe('Justified');
   });
 });
diff --git a/src/lib/zplParser.ts b/src/lib/zplParser.ts
index 41464c33..3c5e6b04 100644
--- a/src/lib/zplParser.ts
+++ b/src/lib/zplParser.ts
@@ -1,4 +1,6 @@
 import type { LabelConfig } from "../types/ObjectType";
+import { zplAnchorToModel } from "../components/Canvas/textPositionTransforms";
+import { computeTextRenderMetrics } from "../components/Canvas/textRenderMetrics";
 import type { LabelObject } from "../types/Group";
 import type { TextProps } from "../registry/text";
 import type { Code128Props } from "../registry/code128";
@@ -21,7 +23,7 @@ import type { CodablockProps } from "../registry/codablock";
 import { putImage } from "./imageCache";
 import { GS1_DATABAR_DEFAULT_SEGMENTS } from "./gs1";
 
-export type ImportFindingKind = 'partial' | 'browserLimit' | 'unknown';
+export type ImportFindingKind = "partial" | "browserLimit" | "unknown";
 
 /**
  * One import finding. Created per-occurrence so each entry can be navigated
@@ -148,7 +150,11 @@ function getDecoder(label: string): TextDecoder {
  * we collect contiguous pairs into a Uint8Array and run one TextDecoder pass
  * per run. Invalid byte sequences become U+FFFD (decoder default).
  */
-function decodeFH(text: string, delimiter: string, decoder: TextDecoder): string {
+function decodeFH(
+  text: string,
+  delimiter: string,
+  decoder: TextDecoder,
+): string {
   const escaped = delimiter.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const runRe = new RegExp(`(?:${escaped}[0-9A-Fa-f]{2})+`, "g");
   const stride = delimiter.length + 2;
@@ -350,11 +356,18 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
   let snIncrement = 1;
   let snMode: SerialProps["zplMode"] = "SN";
 
-  const resetFB = () => { fbWidth = 0; fbLines = 1; fbSpacing = 0; fbJustify = "L"; };
+  const resetFB = () => {
+    fbWidth = 0;
+    fbLines = 1;
+    fbSpacing = 0;
+    fbJustify = "L";
+  };
 
   const flushField = () => {
     if (!fieldType || pendingFD === null) return;
-    const content = fhActive ? decodeFH(pendingFD, fhDelimiter, fhDecoder) : pendingFD;
+    const content = fhActive
+      ? decodeFH(pendingFD, fhDelimiter, fhDecoder)
+      : pendingFD;
     const posType: "FT" | "FO" = positionIsFT ? "FT" : "FO";
     const comment = takeComment();
 
@@ -363,13 +376,31 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
 
     switch (fieldType) {
       case "text": {
+        // ZPL anchors ^FO at cap-top and ^FT at baseline; our internal
+        // model stores the Konva render position (EM-top-left) so editor
+        // interactions stay shift-free. The FO/I and FO/B shifts also
+        // need the rendered ink width — measure it the same way the
+        // renderer does so the round-trip stays exact.
+        const { inkWidthDots } = computeTextRenderMetrics({
+          content: snPending ? `#${decoded}` : decoded,
+          fontHeight: textH,
+          fontWidth: textW,
+          printerFontName: pendingPrinterFontName,
+        });
+        const modelPos = zplAnchorToModel(
+          x,
+          y,
+          { fontHeight: textH, rotation: textRot },
+          posType,
+          inkWidthDots,
+        );
         // If ^SF was pending, create a serial object instead of text
         if (snPending) {
           objects.push(
             makeObj(
               "serial",
-              x,
-              y,
+              modelPos.x,
+              modelPos.y,
               {
                 content: decoded,
                 increment: snIncrement,
@@ -403,7 +434,9 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
           textProps.blockLineSpacing = fbSpacing;
           textProps.blockJustify = fbJustify;
         }
-        objects.push(makeObj("text", x, y, textProps, posType, comment));
+        objects.push(
+          makeObj("text", modelPos.x, modelPos.y, textProps, posType, comment),
+        );
         resetFB();
         break;
       }
@@ -633,7 +666,9 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
 
   // ── Command handler map ────────────────────────────────────────────────────
   const noop: Handler = () => void 0;
-  const resetComment: Handler = (_, rest) => { pendingComment = rest.trim() || undefined; };
+  const resetComment: Handler = (_, rest) => {
+    pendingComment = rest.trim() || undefined;
+  };
   // Hand-written ZPL often splits a logical comment across several `^FX` lines
   // before the field they describe. Accumulate them so each line survives on
   // the imported object's comment field; XA/XZ still reset at label boundaries.
@@ -642,11 +677,13 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
     if (!next) return;
     pendingComment = pendingComment ? `${pendingComment}\n${next}` : next;
   };
-  const mkBrowserLimit = (prefix: string, delimiter = "^"): Handler => (_, rest) => {
-    const tok = `${delimiter}${prefix}${rest}`;
-    skipped.push(tok);
-    browserLimit.push(tok);
-  };
+  const mkBrowserLimit =
+    (prefix: string, delimiter = "^"): Handler =>
+    (_, rest) => {
+      const tok = `${delimiter}${prefix}${rest}`;
+      skipped.push(tok);
+      browserLimit.push(tok);
+    };
 
   const readRotation = (raw: string | undefined): ZplRotation =>
     raw && isZplRotation(raw) ? raw : "N";
@@ -659,21 +696,23 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
 
   // Factory for standard 1D barcode commands that share the same state variables.
   // hIdx/iIdx/cIdx are the comma-split parameter indices for height/interp/check.
-  const mkBarcode = (
-    type: string,
-    hIdx: number,
-    iIdx: number,
-    iDefault = "Y",
-    cIdx = -1,
-  ): Handler => (p) => {
-    fieldType = type;
-    bcRotation = readRotation(p[0]);
-    bcHeight = int(p[hIdx], byHeight || 100);
-    bcInterp = (p[iIdx] ?? iDefault) === "Y";
-    if (cIdx >= 0) bcCheck = (p[cIdx] ?? "N") === "Y";
-  };
+  const mkBarcode =
+    (
+      type: string,
+      hIdx: number,
+      iIdx: number,
+      iDefault = "Y",
+      cIdx = -1,
+    ): Handler =>
+    (p) => {
+      fieldType = type;
+      bcRotation = readRotation(p[0]);
+      bcHeight = int(p[hIdx], byHeight || 100);
+      bcInterp = (p[iIdx] ?? iDefault) === "Y";
+      if (cIdx >= 0) bcCheck = (p[cIdx] ?? "N") === "Y";
+    };
 
-  const getReverseFlag = () => (lrActive || frActive) || undefined;
+  const getReverseFlag = () => lrActive || frActive || undefined;
 
   const handlers: Record<string, Handler> = {
     // ── Label dimensions ────────────────────────────────────────────────────
@@ -761,22 +800,22 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
     // ── Barcodes ────────────────────────────────────────────────────────────
     // mkBarcode(type, hIdx, iIdx, iDefault?, cIdx?)
     // hIdx/iIdx/cIdx = comma-split param positions for height/interp/check
-    BC: mkBarcode("code128",        1, 2, "Y", 4), // ^BCN,h,i,N,c
-    B3: mkBarcode("code39",         2, 3, "Y", 1), // ^B3N,c,h,i,N
-    BE: mkBarcode("ean13",          1, 2),          // ^BEN,h,i,N
-    BU: mkBarcode("upca",           1, 2),          // ^BUN,h,i,N,N
-    B8: mkBarcode("ean8",           1, 2),          // ^B8N,h,i,N
-    B9: mkBarcode("upce",           1, 2),          // ^B9N,h,i,N
-    B2: mkBarcode("interleaved2of5",1, 2, "Y", 4), // ^B2N,h,i,N,c
-    BA: mkBarcode("code93",         1, 2, "Y", 4), // ^BAN,h,i,N,c
-    B1: mkBarcode("code11",         2, 3, "Y", 1), // ^B1N,c,h,i,N
-    BI: mkBarcode("industrial2of5", 1, 2),          // ^BIN,h,i,N
-    BJ: mkBarcode("standard2of5",   1, 2),          // ^BJN,h,i,N
-    BK: mkBarcode("codabar",        2, 3, "Y", 1), // ^BKN,c,h,i,N
-    BL: mkBarcode("logmars",        1, 2, "N"),     // ^BLN,h,i  — interp default N
-    BP: mkBarcode("plessey",        2, 3, "Y", 1), // ^BPN,c,h,i,N
-    B5: mkBarcode("planet",         1, 2),          // ^B5N,h,i,N
-    BZ: mkBarcode("postal",         1, 2),          // ^BZN,h,i,N
+    BC: mkBarcode("code128", 1, 2, "Y", 4), // ^BCN,h,i,N,c
+    B3: mkBarcode("code39", 2, 3, "Y", 1), // ^B3N,c,h,i,N
+    BE: mkBarcode("ean13", 1, 2), // ^BEN,h,i,N
+    BU: mkBarcode("upca", 1, 2), // ^BUN,h,i,N,N
+    B8: mkBarcode("ean8", 1, 2), // ^B8N,h,i,N
+    B9: mkBarcode("upce", 1, 2), // ^B9N,h,i,N
+    B2: mkBarcode("interleaved2of5", 1, 2, "Y", 4), // ^B2N,h,i,N,c
+    BA: mkBarcode("code93", 1, 2, "Y", 4), // ^BAN,h,i,N,c
+    B1: mkBarcode("code11", 2, 3, "Y", 1), // ^B1N,c,h,i,N
+    BI: mkBarcode("industrial2of5", 1, 2), // ^BIN,h,i,N
+    BJ: mkBarcode("standard2of5", 1, 2), // ^BJN,h,i,N
+    BK: mkBarcode("codabar", 2, 3, "Y", 1), // ^BKN,c,h,i,N
+    BL: mkBarcode("logmars", 1, 2, "N"), // ^BLN,h,i  — interp default N
+    BP: mkBarcode("plessey", 2, 3, "Y", 1), // ^BPN,c,h,i,N
+    B5: mkBarcode("planet", 1, 2), // ^B5N,h,i,N
+    BZ: mkBarcode("postal", 1, 2), // ^BZN,h,i,N
 
     // MSI: check logic is "any letter except N" (not simple "Y") — keep inline
     // ^BMN,{checkType},{height},{interp},N  (checkType: A/B/C/D=enabled, N=none)
@@ -794,7 +833,10 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
       bcRotation = readRotation(p[0]);
       byModuleWidth = int(p[2], byModuleWidth);
       gsSymbology = (int(p[1], 1) as Gs1DatabarProps["symbology"]) || 1;
-      gsSegments = p[5] !== undefined ? int(p[5], GS1_DATABAR_DEFAULT_SEGMENTS) : undefined;
+      gsSegments =
+        p[5] !== undefined
+          ? int(p[5], GS1_DATABAR_DEFAULT_SEGMENTS)
+          : undefined;
     },
 
     // ^BQN,2,{magnification} — QR Code
@@ -894,8 +936,12 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
     },
 
     // ── Label reverse / field reverse ───────────────────────────────────────
-    LR(_, rest) { lrActive = rest.toUpperCase().startsWith("Y"); },
-    FR() { frActive = true; },
+    LR(_, rest) {
+      lrActive = rest.toUpperCase().startsWith("Y");
+    },
+    FR() {
+      frActive = true;
+    },
 
     // ── Label home (origin offset) ──────────────────────────────────────────
     LH(p) {
@@ -904,7 +950,9 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
     },
 
     // ── Label top (vertical offset) ─────────────────────────────────────────
-    LT(_, rest) { ltY = int(rest, 0); },
+    LT(_, rest) {
+      ltY = int(rest, 0);
+    },
 
     // ── Graphics ────────────────────────────────────────────────────────────
     GB(p) {
@@ -1066,8 +1114,7 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
       for (let row = 0; row < gfHeightDots; row++) {
         for (let byteIdx = 0; byteIdx < gfBytesPerRow; byteIdx++) {
           const hexOffset = (row * gfBytesPerRow + byteIdx) * 2;
-          const byte =
-            parseInt(gfHex.slice(hexOffset, hexOffset + 2), 16) || 0;
+          const byte = parseInt(gfHex.slice(hexOffset, hexOffset + 2), 16) || 0;
           for (let bit = 0; bit < 8; bit++) {
             const px = byteIdx * 8 + bit;
             const idx = (row * gfWidthDots + px) * 4;
@@ -1304,9 +1351,19 @@ export function parseZPL(zpl: string, dpmm = 8): ParsedZPL {
   // here; `zplImportService.importZplText` fills it once it knows which
   // ^XA…^XZ block this came from.
   const findings: ImportFinding[] = [
-    ...[...partialCmds].map((command): ImportFinding => ({ kind: 'partial', command, pageIndex: 0 })),
-    ...browserLimit.map((command): ImportFinding => ({ kind: 'browserLimit', command, pageIndex: 0 })),
-    ...unknown.map((command): ImportFinding => ({ kind: 'unknown', command, pageIndex: 0 })),
+    ...[...partialCmds].map(
+      (command): ImportFinding => ({ kind: "partial", command, pageIndex: 0 }),
+    ),
+    ...browserLimit.map(
+      (command): ImportFinding => ({
+        kind: "browserLimit",
+        command,
+        pageIndex: 0,
+      }),
+    ),
+    ...unknown.map(
+      (command): ImportFinding => ({ kind: "unknown", command, pageIndex: 0 }),
+    ),
   ];
 
   return {
diff --git a/src/registry/registry.test.ts b/src/registry/registry.test.ts
index 4d140545..ec63fb97 100644
--- a/src/registry/registry.test.ts
+++ b/src/registry/registry.test.ts
@@ -24,7 +24,10 @@ describe('text.toZPL', () => {
     const zpl = def.toZPL(makeObj('text', {
       content: 'Hello', fontHeight: 30, fontWidth: 0, rotation: 'N',
     }));
-    expect(zpl).toContain('^FO100,200');
+    // obj is at (100, 200) — the Konva render position. The emitted ^FO
+    // shifts to the ZPL cap-top anchor: for N h=30, dy = 30 * 0.154 = 4.62,
+    // rounded to integer dots = 5 ⇒ 200 + 5 = 205.
+    expect(zpl).toContain('^FO100,205');
     expect(zpl).toContain('^A0N,30,0');
     expect(zpl).toContain('^FDHello^FS');
   });
@@ -33,7 +36,9 @@ describe('text.toZPL', () => {
     const zpl = def.toZPL(makeObj('text', {
       content: 'Hi', fontHeight: 20, fontWidth: 0, rotation: 'N',
     }, { positionType: 'FT' }));
-    expect(zpl).toContain('^FT100,200');
+    // FT shifts to the baseline: for N h=20, dy = 20 * 0.92 = 18.4,
+    // rounded to integer dots = 18 ⇒ 200 + 18 = 218.
+    expect(zpl).toContain('^FT100,218');
   });
 
   it('emits ^LRY / ^LRN when reverse is true', () => {
diff --git a/src/registry/serial.tsx b/src/registry/serial.tsx
index d79ac0fe..774ca662 100644
--- a/src/registry/serial.tsx
+++ b/src/registry/serial.tsx
@@ -1,45 +1,56 @@
-import type { ObjectTypeDefinition } from '../types/ObjectType';
-import { useT } from '../lib/useT';
-import { inputCls, labelCls } from '../components/Properties/styles';
-import { fieldPos, fdField } from './zplHelpers';
-import { filterContent, type ContentSpec } from './contentSpec';
-import { RotationSelect } from '../components/Properties/RotationSelect';
-import { NumberInput } from '../components/Properties/NumberInput';
+import type { ObjectTypeDefinition } from "../types/ObjectType";
+import { useT } from "../lib/useT";
+import { inputCls, labelCls } from "../components/Properties/styles";
+import { textFieldPos, fdField } from "./zplHelpers";
+import { effectiveScale } from "./transformHelpers";
+import { filterContent, type ContentSpec } from "./contentSpec";
+import { RotationSelect } from "../components/Properties/RotationSelect";
+import { NumberInput } from "../components/Properties/NumberInput";
 
-const serialSpec: ContentSpec = { charset: '0-9A-Za-z' };
+const serialSpec: ContentSpec = { charset: "0-9A-Za-z" };
 
 export interface SerialProps {
   content: string;
   increment: number;
   fontHeight: number;
   fontWidth: number;
-  rotation: 'N' | 'R' | 'I' | 'B';
-  zplMode: 'SF' | 'SN';
+  rotation: "N" | "R" | "I" | "B";
+  zplMode: "SF" | "SN";
 }
 
 export const serial: ObjectTypeDefinition<SerialProps> = {
-  label: 'Serial',
-  icon: '#',
-  group: 'text' as const,
+  label: "Serial",
+  icon: "#",
+  group: "text" as const,
   defaultProps: {
-    content: '001',
+    content: "001",
     increment: 1,
     fontHeight: 30,
     fontWidth: 0,
-    rotation: 'N',
-    zplMode: 'SN',
+    rotation: "N",
+    zplMode: "SN",
   },
   defaultSize: { width: 100, height: 30 },
+  // Rectangle resize matching text.tsx — see notes there.
+  commitTransform: (obj, ctx) => {
+    const oldH = obj.props.fontHeight;
+    const oldW = obj.props.fontWidth > 0 ? obj.props.fontWidth : oldH;
+    const { esx, esy } = effectiveScale(obj.props.rotation, ctx);
+    return {
+      fontHeight: Math.max(1, ctx.snap(Math.round(oldH * esy))),
+      fontWidth: Math.max(1, ctx.snap(Math.round(oldW * esx))),
+    };
+  },
 
   toZPL: (obj) => {
     const p = obj.props;
-    const field = `${fieldPos(obj)}^A0${p.rotation},${p.fontHeight},${p.fontWidth}`;
+    const field = `${textFieldPos(obj)}^A0${p.rotation},${p.fontHeight},${p.fontWidth}`;
     // Re-apply the input charset filter at emit time so ZPL-imported content
     // (which bypasses the in-app filter) can't smuggle ^/~ into the ^SN start
     // parameter or comma-split the parameter list. fdField additionally
     // hex-escapes any survivors in the FD payload — belt and suspenders.
     const safe = filterContent(p.content, serialSpec);
-    if (p.zplMode === 'SF') {
+    if (p.zplMode === "SF") {
       // ^SF: increment, pad-digits (derived from content length), change-per-label
       return `${field}^SF${p.increment},${safe.length},Y${fdField(safe)}`;
     }
@@ -58,7 +69,9 @@ export const serial: ObjectTypeDefinition<SerialProps> = {
             <input
               className={inputCls}
               value={p.content}
-              onChange={(e) => onChange({ content: filterContent(e.target.value, serialSpec) })}
+              onChange={(e) =>
+                onChange({ content: filterContent(e.target.value, serialSpec) })
+              }
             />
           </div>
           <NumberInput
@@ -94,7 +107,9 @@ export const serial: ObjectTypeDefinition<SerialProps> = {
           <select
             className={inputCls}
             value={p.zplMode}
-            onChange={(e) => onChange({ zplMode: e.target.value as SerialProps['zplMode'] })}
+            onChange={(e) =>
+              onChange({ zplMode: e.target.value as SerialProps["zplMode"] })
+            }
           >
             <option value="SN">{t.registry.serial.zplModeSN}</option>
             <option value="SF">{t.registry.serial.zplModeSF}</option>
diff --git a/src/registry/text.tsx b/src/registry/text.tsx
index 8f5650ca..10d28395 100644
--- a/src/registry/text.tsx
+++ b/src/registry/text.tsx
@@ -1,18 +1,19 @@
-import { useRef, useState, useCallback } from 'react';
-import type { ObjectTypeDefinition } from '../types/ObjectType';
-import { useT } from '../lib/useT';
-import { inputCls, labelCls } from '../components/Properties/styles';
-import { fieldPos, fdField } from './zplHelpers';
-import { getFont, getAllFonts, loadFontFile } from '../lib/fontCache';
-import { useFontCacheVersion } from '../hooks/useFontCacheVersion';
-import { RotationSelect } from '../components/Properties/RotationSelect';
-import { NumberInput } from '../components/Properties/NumberInput';
+import { useRef, useState, useCallback } from "react";
+import type { ObjectTypeDefinition } from "../types/ObjectType";
+import { useT } from "../lib/useT";
+import { inputCls, labelCls } from "../components/Properties/styles";
+import { textFieldPos, fdField } from "./zplHelpers";
+import { effectiveScale } from "./transformHelpers";
+import { getFont, getAllFonts, loadFontFile } from "../lib/fontCache";
+import { useFontCacheVersion } from "../hooks/useFontCacheVersion";
+import { RotationSelect } from "../components/Properties/RotationSelect";
+import { NumberInput } from "../components/Properties/NumberInput";
 
 export interface TextProps {
   content: string;
   fontHeight: number;
   fontWidth: number;
-  rotation: 'N' | 'R' | 'I' | 'B';
+  rotation: "N" | "R" | "I" | "B";
   reverse?: boolean;
   /** Printer TrueType font filename from ^A@ (e.g. "ARIAL.TTF") */
   printerFontName?: string;
@@ -20,24 +21,36 @@ export interface TextProps {
   blockWidth?: number;
   blockLines?: number;
   blockLineSpacing?: number;
-  blockJustify?: 'L' | 'C' | 'R' | 'J';
+  blockJustify?: "L" | "C" | "R" | "J";
 }
 
 export const text: ObjectTypeDefinition<TextProps> = {
-  label: 'Text',
-  icon: 'T',
-  group: 'text' as const,
+  label: "Text",
+  icon: "T",
+  group: "text" as const,
   defaultProps: {
-    content: 'Text',
+    content: "Text",
     fontHeight: 30,
     fontWidth: 0,
-    rotation: 'N',
+    rotation: "N",
   },
   defaultSize: { width: 200, height: 40 },
-
-  commitTransform: (obj, { sy, snap }) => ({
-    fontHeight: Math.max(1, snap(Math.round(obj.props.fontHeight * sy))),
-  }),
+  // Rectangle resize: corner drag updates fontHeight from sy and
+  // fontWidth from sx independently. fontWidth=0 in storage is the
+  // Zebra default meaning "match height"; in that case the effective
+  // pre-resize width equals fontHeight, so we scale that derived value
+  // by sx and persist the result. `effectiveScale` flips sx/sy for R/B
+  // rotations so the user's screen-vertical drag stays attached to
+  // fontHeight regardless of how Konva orients the glyphs.
+  commitTransform: (obj, ctx) => {
+    const oldH = obj.props.fontHeight;
+    const oldW = obj.props.fontWidth > 0 ? obj.props.fontWidth : oldH;
+    const { esx, esy } = effectiveScale(obj.props.rotation, ctx);
+    return {
+      fontHeight: Math.max(1, ctx.snap(Math.round(oldH * esy))),
+      fontWidth: Math.max(1, ctx.snap(Math.round(oldW * esx))),
+    };
+  },
 
   toZPL: (obj) => {
     const p = obj.props;
@@ -45,16 +58,18 @@ export const text: ObjectTypeDefinition<TextProps> = {
       ? `^A@${p.rotation},${p.fontHeight},${p.fontWidth},E:${p.printerFontName}`
       : `^A0${p.rotation},${p.fontHeight},${p.fontWidth}`;
     const fbCmd = p.blockWidth
-      ? `^FB${p.blockWidth},${p.blockLines ?? 1},${p.blockLineSpacing ?? 0},${p.blockJustify ?? 'L'},0`
-      : '';
+      ? `^FB${p.blockWidth},${p.blockLines ?? 1},${p.blockLineSpacing ?? 0},${p.blockJustify ?? "L"},0`
+      : "";
     return [
-      p.reverse ? '^LRY' : '',
-      fieldPos(obj),
+      p.reverse ? "^LRY" : "",
+      textFieldPos(obj),
       fontCmd,
       fbCmd,
       fdField(p.content),
-      p.reverse ? '^LRN' : '',
-    ].filter(Boolean).join('');
+      p.reverse ? "^LRN" : "",
+    ]
+      .filter(Boolean)
+      .join("");
   },
 
   PropertiesPanel: ({ obj, onChange }) => {
@@ -68,15 +83,18 @@ export const text: ObjectTypeDefinition<TextProps> = {
     const fontLoaded = !!p.printerFontName && !!getFont(p.printerFontName);
     const fontAssignedButMissing = !!p.printerFontName && !fontLoaded;
 
-    const handleFontUpload = useCallback(async (file: File) => {
-      if (!p.printerFontName) return;
-      setUploading(true);
-      try {
-        await loadFontFile(file, p.printerFontName);
-      } finally {
-        setUploading(false);
-      }
-    }, [p.printerFontName]);
+    const handleFontUpload = useCallback(
+      async (file: File) => {
+        if (!p.printerFontName) return;
+        setUploading(true);
+        try {
+          await loadFontFile(file, p.printerFontName);
+        } finally {
+          setUploading(false);
+        }
+      },
+      [p.printerFontName],
+    );
 
     return (
       <div className="flex flex-col gap-3">
@@ -84,23 +102,31 @@ export const text: ObjectTypeDefinition<TextProps> = {
           <label className={labelCls}>{t.registry.text.printerFont}</label>
           <select
             className={inputCls}
-            value={p.printerFontName ?? ''}
-            onChange={(e) => onChange({ printerFontName: e.target.value || undefined })}
+            value={p.printerFontName ?? ""}
+            onChange={(e) =>
+              onChange({ printerFontName: e.target.value || undefined })
+            }
           >
             <option value="">{t.registry.text.noFont}</option>
             {loadedFonts.map((f) => (
-              <option key={f.name} value={f.name}>{f.name}</option>
+              <option key={f.name} value={f.name}>
+                {f.name}
+              </option>
             ))}
             {p.printerFontName && !getFont(p.printerFontName) && (
               <option value={p.printerFontName}>{p.printerFontName}</option>
             )}
           </select>
           {fontLoaded && (
-            <span className="text-[10px] text-accent font-mono">{t.registry.text.fontLoaded}</span>
+            <span className="text-[10px] text-accent font-mono">
+              {t.registry.text.fontLoaded}
+            </span>
           )}
           {fontAssignedButMissing && (
             <>
-              <span className="text-[10px] text-muted font-mono">{t.registry.text.fontMissing}</span>
+              <span className="text-[10px] text-muted font-mono">
+                {t.registry.text.fontMissing}
+              </span>
               <input
                 ref={fileRef}
                 type="file"
@@ -109,7 +135,7 @@ export const text: ObjectTypeDefinition<TextProps> = {
                 onChange={(e) => {
                   const file = e.target.files?.[0];
                   if (file) void handleFontUpload(file);
-                  e.target.value = '';
+                  e.target.value = "";
                 }}
               />
               <button
@@ -118,7 +144,9 @@ export const text: ObjectTypeDefinition<TextProps> = {
                 onClick={() => fileRef.current?.click()}
                 disabled={uploading}
               >
-                {uploading ? t.registry.text.uploadingFont : t.registry.text.uploadFont}
+                {uploading
+                  ? t.registry.text.uploadingFont
+                  : t.registry.text.uploadFont}
               </button>
             </>
           )}
@@ -168,10 +196,23 @@ export const text: ObjectTypeDefinition<TextProps> = {
             type="checkbox"
             className="accent-accent"
             checked={!!p.blockWidth}
-            onChange={(e) => onChange(e.target.checked
-              ? { blockWidth: 400, blockLines: 3, blockLineSpacing: 0, blockJustify: 'L' }
-              : { blockWidth: undefined, blockLines: undefined, blockLineSpacing: undefined, blockJustify: undefined },
-            )}
+            onChange={(e) =>
+              onChange(
+                e.target.checked
+                  ? {
+                      blockWidth: 400,
+                      blockLines: 3,
+                      blockLineSpacing: 0,
+                      blockJustify: "L",
+                    }
+                  : {
+                      blockWidth: undefined,
+                      blockLines: undefined,
+                      blockLineSpacing: undefined,
+                      blockJustify: undefined,
+                    },
+              )
+            }
           />
           <span className={labelCls}>{t.registry.text.fieldBlock}</span>
         </label>
@@ -194,11 +235,17 @@ export const text: ObjectTypeDefinition<TextProps> = {
             </div>
             <div className="grid grid-cols-2 gap-2">
               <div className="flex flex-col gap-1">
-                <label className={labelCls}>{t.registry.text.blockJustify}</label>
+                <label className={labelCls}>
+                  {t.registry.text.blockJustify}
+                </label>
                 <select
                   className={inputCls}
-                  value={p.blockJustify ?? 'L'}
-                  onChange={(e) => onChange({ blockJustify: e.target.value as TextProps['blockJustify'] })}
+                  value={p.blockJustify ?? "L"}
+                  onChange={(e) =>
+                    onChange({
+                      blockJustify: e.target.value as TextProps["blockJustify"],
+                    })
+                  }
                 >
                   <option value="L">{t.registry.text.justifyL}</option>
                   <option value="C">{t.registry.text.justifyC}</option>
diff --git a/src/registry/transformHelpers.ts b/src/registry/transformHelpers.ts
index 1702e156..b0416f44 100644
--- a/src/registry/transformHelpers.ts
+++ b/src/registry/transformHelpers.ts
@@ -5,6 +5,23 @@ export function clamp(min: number, max: number, value: number): number {
   return Math.max(min, Math.min(max, value));
 }
 
+/** ZPL rotates the rendered content but the Konva wrapper Group stays
+ *  axis-aligned, so `sx`/`sy` from the transformer are always in screen
+ *  space. For rotation R / B (90° / 270°) the user's screen-vertical
+ *  drag therefore targets the pre-rotation X axis (text/bar-width)
+ *  rather than the pre-rotation Y axis (height) — swap the two so each
+ *  commit helper can keep talking about "x-prop" and "y-prop" without
+ *  having to know about rotation. N and I both leave the axes aligned. */
+export function effectiveScale(
+  rotation: "N" | "R" | "I" | "B" | undefined,
+  ctx: TransformContext,
+): { esx: number; esy: number } {
+  const swap = rotation === "R" || rotation === "B";
+  return swap
+    ? { esx: ctx.sy, esy: ctx.sx }
+    : { esx: ctx.sx, esy: ctx.sy };
+}
+
 /**
  * Factory for commitTransform on uniformly-scaling 2D codes (QR, Aztec,
  * DataMatrix): a single integer module-size prop scales by min(sx, sy)
@@ -39,22 +56,27 @@ export function commitWidthHeightTransform<P extends WidthHeightProps>(
 }
 
 /**
- * commitTransform for 1D barcodes. Vertical drag scales bar height (sy),
- * horizontal drag scales the module width (sx) — the latter is clamped
- * to the ZPL `^BY` range [1, 10]. During the drag the bitmap stretches
+ * commitTransform for 1D barcodes. Vertical drag scales bar height,
+ * horizontal drag scales the module width — the latter is clamped to
+ * the ZPL `^BY` range [1, 10]. During the drag the bitmap stretches
  * free-form for visual feedback; this commit rounds the result to a
  * valid integer moduleWidth on release.
+ *
+ * `effectiveScale` swaps sx/sy for R/B-rotated barcodes so user's
+ * screen-vertical drag stays attached to bar height regardless of how
+ * the bitmap is oriented on screen.
  */
 export function commitBarcodeWidthHeightTransform<
-  P extends { height: number; moduleWidth: number },
+  P extends { height: number; moduleWidth: number; rotation: "N" | "R" | "I" | "B" },
 >(
   obj: LabelObjectBase & { props: P },
   ctx: TransformContext,
 ): Partial<P> {
-  const { sx, sy, snap } = ctx;
+  const { snap } = ctx;
+  const { esx, esy } = effectiveScale(obj.props.rotation, ctx);
   return {
-    height: Math.max(1, snap(Math.round(obj.props.height * sy))),
-    moduleWidth: clamp(1, 10, Math.round(obj.props.moduleWidth * sx)),
+    height: Math.max(1, snap(Math.round(obj.props.height * esy))),
+    moduleWidth: clamp(1, 10, Math.round(obj.props.moduleWidth * esx)),
   } as Partial<P>;
 }
 
@@ -67,19 +89,23 @@ interface Stacked2DProps {
  * Shared commitTransform for stacked 2D barcodes (pdf417, micropdf417,
  * codablock). The drag-start anchor pins the rowHeight grid so the final
  * value matches the snap performed during the drag (boundBoxFunc).
+ * Rotation-aware via `effectiveScale`, same reasoning as the 1D helper.
  */
-export function commitStacked2DTransform<P extends Stacked2DProps>(
+export function commitStacked2DTransform<
+  P extends Stacked2DProps & { rotation: "N" | "R" | "I" | "B" },
+>(
   obj: LabelObjectBase & { props: P },
   ctx: TransformContext,
 ): Partial<P> {
-  const { sx, sy, snap, nodeHeight, anchor } = ctx;
-  const scaledH = nodeHeight * sy;
+  const { snap, nodeHeight, anchor } = ctx;
+  const { esx, esy } = effectiveScale(obj.props.rotation, ctx);
+  const scaledH = nodeHeight * esy;
   const newRowHeight =
     anchor && anchor.nodeHeight > 0 && anchor.rowHeight > 0
       ? Math.max(1, Math.round((scaledH * anchor.rowHeight) / anchor.nodeHeight))
-      : Math.max(1, snap(Math.round(obj.props.rowHeight * sy)));
+      : Math.max(1, snap(Math.round(obj.props.rowHeight * esy)));
   return {
     rowHeight: newRowHeight,
-    moduleWidth: clamp(1, 10, Math.round(obj.props.moduleWidth * sx)),
+    moduleWidth: clamp(1, 10, Math.round(obj.props.moduleWidth * esx)),
   } as Partial<P>;
 }
diff --git a/src/registry/zplHelpers.ts b/src/registry/zplHelpers.ts
index 50d4b959..9c0e3957 100644
--- a/src/registry/zplHelpers.ts
+++ b/src/registry/zplHelpers.ts
@@ -1,11 +1,39 @@
-import type { LabelObjectBase } from '../types/ObjectType';
+import type { LabelObjectBase } from "../types/ObjectType";
+import { modelToZplAnchor } from "../components/Canvas/textPositionTransforms";
+import { getTextRenderMetrics } from "../components/Canvas/textRenderMetrics";
+import type { LabelObject } from "../types/Group";
 
 /** Emit `^FT` or `^FO` depending on how the object was originally positioned. */
 export function fieldPos(obj: LabelObjectBase): string {
-  const cmd = obj.positionType === 'FT' ? 'FT' : 'FO';
+  const cmd = obj.positionType === "FT" ? "FT" : "FO";
   return `^${cmd}${obj.x},${obj.y}`;
 }
 
+interface TextLikeObjForFieldPos extends LabelObjectBase {
+  props: { fontHeight: number; rotation: "N" | "R" | "I" | "B" };
+}
+
+/** Emit `^FT` or `^FO` for text/serial objects. obj.x/y is stored as the
+ *  Konva render position (EM top-left); the ZPL anchor (cap-top for ^FO,
+ *  baseline for ^FT) sits a rotation- and positionType-dependent offset
+ *  away. This conversion happens here so editor interactions stay in a
+ *  single coord system. */
+export function textFieldPos(obj: TextLikeObjForFieldPos): string {
+  const cmd = obj.positionType === "FT" ? "FT" : "FO";
+  const metrics = getTextRenderMetrics(obj as unknown as LabelObject);
+  const a = modelToZplAnchor(
+    obj.x,
+    obj.y,
+    obj.props,
+    obj.positionType,
+    metrics?.inkWidthDots ?? 0,
+  );
+  // Round to integer dots: ZPL ^FO/^FT take integer coordinates and the
+  // shift math adds non-trivial fractional residue that the printer
+  // firmware would truncate anyway.
+  return `^${cmd}${Math.round(a.x)},${Math.round(a.y)}`;
+}
+
 /**
  * Remove ZPL command/format prefixes from free-form text. `^FX` (comment) and
  * other text-only contexts have no `^FH` escape mechanism, so these chars
@@ -13,14 +41,16 @@ export function fieldPos(obj: LabelObjectBase): string {
  * surrounding command.
  */
 export function stripZplCommandChars(s: string): string {
-  return s.replace(/[\^~]/g, '');
+  return s.replace(/[\^~]/g, "");
 }
 
-const FH_DELIM = '_';
+const FH_DELIM = "_";
 const NEEDS_FH = /[\^~]/;
 
 function hex(ch: string): string {
-  return FH_DELIM + ch.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0');
+  return (
+    FH_DELIM + ch.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")
+  );
 }
 
 /**
diff --git a/src/test/textBoxMatch.test.ts b/src/test/textBoxMatch.test.ts
new file mode 100644
index 00000000..5525c152
--- /dev/null
+++ b/src/test/textBoxMatch.test.ts
@@ -0,0 +1,141 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { createCanvas, GlobalFonts } from '@napi-rs/canvas';
+import { PNG } from 'pngjs';
+import { textBoxMatchCases } from '../../tests/fixtures/textBoxMatchCases';
+
+/**
+ * Box-match regression.
+ *
+ * Asserts that our local @napi-rs/canvas render (with PrintLab ZPL)
+ * produces a glyph bounding box within a small tolerance of what
+ * Labelary prints using the default Zebra firmware font (^A0,
+ * CG Triumvirate). That's the comparison the user actually cares
+ * about: "if my editor says this text fits, will it also fit on the
+ * printed label?".
+ *
+ * We compare BBOX DIMENSIONS, not pixel content. The two fonts have
+ * different glyph designs (Roboto vs. CG Triumvirate), so pixel-perfect
+ * match is impossible — but the rendered footprint can and must
+ * match for layout to be trustworthy.
+ *
+ * Test cases are `char × 3` patterns at multiple sizes (see
+ * tests/fixtures/textBoxMatchCases.ts) covering digits, alpha caps,
+ * alpha lowercase, and the punctuation chars Zebra renders unusually
+ * wide. Fixture generation lives in
+ * tests/scripts/fetch_labelary_default_text_fixtures.ts.
+ */
+
+const FIXTURES_DIR = path.resolve(
+  process.cwd(),
+  'tests/fixtures/labelary_text_default_images',
+);
+const FONT_PATH = path.resolve(
+  process.cwd(),
+  'src/assets/fonts/PrintLabZPL-Bold.ttf',
+);
+
+const CANVAS_PX = 812;
+const FONT_FAMILY = 'PrintLab ZPL';
+
+/** Per-axis tolerance in dots. Cap-bound and digit content lands at
+ *  ≤3 dots once the font's per-glyph advance and vertical scaling are
+ *  applied. The 6-dot allowance covers ascender / descender outliers
+ *  where Roboto's inherent vertical proportions disagree with
+ *  CG Triumvirate's by a few dots — visible only for `i` (dot above
+ *  x-height), `p` (descender) and `.` (baseline edge). A real layout
+ *  regression (wrong advance class, wrong fontSize) produces drift
+ *  >12 dots even at small sizes, well above this ceiling. */
+const BBOX_TOLERANCE_DOTS = 6;
+
+interface BBox {
+  width: number;
+  height: number;
+}
+
+/** Scan a PNG for the smallest rectangle that contains all darkish
+ *  pixels. Returns extent in pixels (= dots on our 8 dpmm canvas). */
+function darkBBox(png: PNG): BBox {
+  const { width, height, data } = png;
+  let minX = width;
+  let minY = height;
+  let maxX = -1;
+  let maxY = -1;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const idx = (y * width + x) * 4;
+      const lum =
+        0.299 * (data[idx] ?? 0) +
+        0.587 * (data[idx + 1] ?? 0) +
+        0.114 * (data[idx + 2] ?? 0);
+      if (lum < 200) {
+        if (x < minX) minX = x;
+        if (y < minY) minY = y;
+        if (x > maxX) maxX = x;
+        if (y > maxY) maxY = y;
+      }
+    }
+  }
+  if (maxX < 0) return { width: 0, height: 0 };
+  return { width: maxX - minX + 1, height: maxY - minY + 1 };
+}
+
+describe('Text Box-Match — PrintLab ZPL vs. Labelary default font', () => {
+  beforeAll(() => {
+    if (!fs.existsSync(FONT_PATH)) {
+      throw new Error(`Font file missing at ${FONT_PATH}`);
+    }
+    GlobalFonts.registerFromPath(FONT_PATH, FONT_FAMILY);
+  });
+
+  it('has default-font fixtures (run fetch_labelary_default_text_fixtures.ts if this fails)', () => {
+    expect(textBoxMatchCases.length).toBeGreaterThan(0);
+    for (const tc of textBoxMatchCases) {
+      const fixture = path.join(FIXTURES_DIR, `${tc.id}.png`);
+      expect(fs.existsSync(fixture), `Missing fixture ${tc.id}.png`).toBe(true);
+    }
+  });
+
+  describe.each(textBoxMatchCases)('Box: $id', (tc) => {
+    it(`bbox matches Labelary default within ±${BBOX_TOLERANCE_DOTS} dots`, () => {
+      // Render our font locally exactly as production does.
+      const canvas = createCanvas(CANVAS_PX, CANVAS_PX);
+      const ctx = canvas.getContext('2d');
+      ctx.fillStyle = 'white';
+      ctx.fillRect(0, 0, CANVAS_PX, CANVAS_PX);
+      ctx.fillStyle = 'black';
+      ctx.font = `bold ${tc.fontHeight}px "${FONT_FAMILY}"`;
+      ctx.textBaseline = 'top';
+      // Mirror Konva's scaleX: ZPL `^A0,h,w` with w != h stretches each
+      // glyph horizontally; w = 0 is the Zebra shorthand for "match h".
+      const scaleX = tc.fontWidth > 0 ? tc.fontWidth / tc.fontHeight : 1;
+      ctx.save();
+      ctx.translate(tc.x, tc.y);
+      ctx.scale(scaleX, 1);
+      ctx.fillText(tc.text, 0, 0);
+      ctx.restore();
+
+      const localPng = PNG.sync.read(canvas.toBuffer('image/png'));
+      const labelaryPng = PNG.sync.read(
+        fs.readFileSync(path.join(FIXTURES_DIR, `${tc.id}.png`)),
+      );
+
+      const localBox = darkBBox(localPng);
+      const labelaryBox = darkBBox(labelaryPng);
+
+      expect(localBox.width, `width drift for ${tc.id}`).toBeGreaterThanOrEqual(
+        labelaryBox.width - BBOX_TOLERANCE_DOTS,
+      );
+      expect(localBox.width).toBeLessThanOrEqual(
+        labelaryBox.width + BBOX_TOLERANCE_DOTS,
+      );
+      expect(localBox.height, `height drift for ${tc.id}`).toBeGreaterThanOrEqual(
+        labelaryBox.height - BBOX_TOLERANCE_DOTS,
+      );
+      expect(localBox.height).toBeLessThanOrEqual(
+        labelaryBox.height + BBOX_TOLERANCE_DOTS,
+      );
+    });
+  });
+});
diff --git a/src/test/textVisualRegression.test.ts b/src/test/textVisualRegression.test.ts
new file mode 100644
index 00000000..bc5417bb
--- /dev/null
+++ b/src/test/textVisualRegression.test.ts
@@ -0,0 +1,116 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { createCanvas, GlobalFonts } from '@napi-rs/canvas';
+import pixelmatch from 'pixelmatch';
+import { PNG } from 'pngjs';
+import { textTestCases } from '../../tests/fixtures/textTestCases';
+
+/**
+ * Text rendering visual regression.
+ *
+ * Both sides load the SAME font (our PrintLabZPL-Bold.ttf):
+ *   - Labelary uploaded it via /v1/fonts before generating the fixtures
+ *     (see tests/scripts/fetch_labelary_text_fixtures.ts).
+ *   - The local render here registers the TTF with @napi-rs/canvas.
+ *
+ * That removes glyph-design variance from the diff entirely. The
+ * residual pixels are anti-aliasing edges between Labelary's renderer
+ * and @napi-rs/canvas's renderer, which is small enough to flag real
+ * regressions without flapping on noise.
+ *
+ * Production uses `ZPL_FONT_HEIGHT_TO_CSS_RATIO = 1.0`, i.e. canvas
+ * fontSize equals ZPL fontHeight directly. The test mirrors that so
+ * the regression catches anything that breaks the live render path.
+ */
+const FIXTURES_DIR = path.resolve(
+  process.cwd(),
+  'tests/fixtures/labelary_text_images',
+);
+const DIFF_DIR = path.resolve(process.cwd(), 'tests/fixtures/__text_diffs__');
+const FONT_PATH = path.resolve(process.cwd(), 'src/assets/fonts/PrintLabZPL-Bold.ttf');
+
+const CANVAS_PX = 812; // 4x4 inch at 8 dpmm — matches the fixture canvas.
+const FONT_FAMILY = 'PrintLab ZPL';
+
+/** Diff allowance. With both sides loading the same TTF the remaining
+ *  delta is anti-aliasing edge variance between the renderers — sized
+ *  with the glyph perimeter rather than the area, so a flat ceiling
+ *  generous enough for the largest case in the matrix still leaves an
+ *  order of magnitude of headroom before a real regression (wrong font
+ *  loaded, wrong fontSize, wrong rotation) breaches it. Measured high
+ *  watermark across the current suite is ~5700; an actual regression
+ *  produces >20000 even at small fontHeights. */
+const ALLOWED_PX_DIFF = 8000;
+
+if (!fs.existsSync(DIFF_DIR)) {
+  fs.mkdirSync(DIFF_DIR, { recursive: true });
+}
+
+describe('Text Visual Regression — PrintLab ZPL on both sides', () => {
+  beforeAll(() => {
+    if (!fs.existsSync(FONT_PATH)) {
+      throw new Error(`Font file missing at ${FONT_PATH}.`);
+    }
+    GlobalFonts.registerFromPath(FONT_PATH, FONT_FAMILY);
+  });
+
+  it('has fixtures (run fetch_labelary_text_fixtures.ts if this fails)', () => {
+    expect(textTestCases.length).toBeGreaterThan(0);
+    for (const tc of textTestCases) {
+      const fixture = path.join(FIXTURES_DIR, `${tc.id}.png`);
+      expect(
+        fs.existsSync(fixture),
+        `Missing fixture ${tc.id}.png — run tests/scripts/fetch_labelary_text_fixtures.ts`,
+      ).toBe(true);
+    }
+  });
+
+  describe.each(textTestCases)('Text: $id', (tc) => {
+    it('matches Labelary within anti-aliasing tolerance', () => {
+      // Local render: PrintLab ZPL at fontSize = fontHeight, anchored
+      // at the same FO origin as the fixture. Production sets
+      // `textBaseline = 'top'` implicitly via Konva.Text's anchor model,
+      // so we mirror that here.
+      const canvas = createCanvas(CANVAS_PX, CANVAS_PX);
+      const ctx = canvas.getContext('2d');
+      ctx.fillStyle = 'white';
+      ctx.fillRect(0, 0, CANVAS_PX, CANVAS_PX);
+      ctx.fillStyle = 'black';
+      ctx.font = `bold ${tc.fontHeight}px "${FONT_FAMILY}"`;
+      ctx.textBaseline = 'top';
+      ctx.fillText(tc.text, tc.x, tc.y);
+      const localPng = PNG.sync.read(canvas.toBuffer('image/png'));
+
+      const fixtureBuf = fs.readFileSync(path.join(FIXTURES_DIR, `${tc.id}.png`));
+      const fixturePng = PNG.sync.read(fixtureBuf);
+      expect(fixturePng.width).toBe(CANVAS_PX);
+      expect(fixturePng.height).toBe(CANVAS_PX);
+
+      const diff = new PNG({ width: CANVAS_PX, height: CANVAS_PX });
+      const diffCount = pixelmatch(
+        fixturePng.data,
+        localPng.data,
+        diff.data,
+        CANVAS_PX,
+        CANVAS_PX,
+        { threshold: 0.1 },
+      );
+
+      if (diffCount > ALLOWED_PX_DIFF) {
+        // Write the diff and local PNGs so a CI failure is debuggable
+        // without re-running the script locally.
+        fs.writeFileSync(
+          path.join(DIFF_DIR, `${tc.id}_diff.png`),
+          PNG.sync.write(diff),
+        );
+        fs.writeFileSync(
+          path.join(DIFF_DIR, `${tc.id}_local.png`),
+          canvas.toBuffer('image/png'),
+        );
+      }
+
+      expect(diffCount).toBeLessThanOrEqual(ALLOWED_PX_DIFF);
+    });
+  });
+});
diff --git a/src/test/zplRoundtrip.test.ts b/src/test/zplRoundtrip.test.ts
index 1f344ace..dff40522 100644
--- a/src/test/zplRoundtrip.test.ts
+++ b/src/test/zplRoundtrip.test.ts
@@ -225,11 +225,13 @@ const LH_OFFSET_ZPL = `
 
 describe('round-trip — ^LH label home offset', () => {
   it('bakes the ^LH offset into absolute object positions', () => {
-    // After import the LH offset is merged into x/y — objects sit at FO+LH
+    // After import the LH offset is merged into x/y — objects sit at FO+LH.
+    // Text additionally subtracts the ZPL-anchor-to-EM shift so obj.x/y
+    // is the Konva render position. For ^A0N h=25 FO: dy = 25 * 0.154 = 3.85.
     const { first } = roundtrip(LH_OFFSET_ZPL);
     const text = first.objects.find((o) => o.type === 'text');
-    expect(text?.x).toBe(100); // 70 + 30
-    expect(text?.y).toBe(100); // 80 + 20
+    expect(text?.x).toBeCloseTo(100); // 70 + 30
+    expect(text?.y).toBeCloseTo(100 - 3.85); // 80 + 20 - shift
   });
 
   it('preserves object positions across the round-trip', () => {
@@ -295,6 +297,50 @@ describe('round-trip — comma in ^FD content', () => {
 
 // ── real-world Zebra Designer header commands ─────────────────────────────────
 
+// ── text rotation × positionType byte-exact round-trip ─────────────────────
+//
+// Regression guard for the model-vs-ZPL coordinate split: obj.x/y is the
+// Konva render position (EM-top-left); the ZPL emit / parse pair adds /
+// subtracts a rotation- and positionType-dependent offset. If those two
+// functions drift apart, the rendered Konva position no longer matches
+// the printed ZPL anchor for rotated text — invisibly, until preview /
+// print catches it. This loops every rotation × {FO, FT} combination at
+// realistic fontHeights and asserts the original ZPL bytes survive a
+// parse → generate cycle.
+
+describe('round-trip — text rotation × positionType preservation', () => {
+  for (const pos of ['FO', 'FT'] as const) {
+    for (const rot of ['N', 'R', 'I', 'B'] as const) {
+      for (const fontHeight of [20, 30, 50, 87]) {
+        it(`preserves ^${pos} x,y for rotation ${rot} h=${fontHeight}`, () => {
+          const inputZpl =
+            `^XA^${pos}123,456^A0${rot},${fontHeight},0^FDHello^FS^XZ`;
+          const { regenerated } = roundtrip(inputZpl);
+          // The emitted ZPL must contain the same ^FO/^FT coordinates and
+          // ^A0 declaration as the input — anything else means the
+          // model↔ZPL shift drifted between parser and generator.
+          expect(regenerated).toContain(`^${pos}123,456`);
+          expect(regenerated).toContain(`^A0${rot},${fontHeight},0`);
+        });
+      }
+    }
+  }
+
+  it('preserves coordinates through two parse-generate cycles', () => {
+    const inputZpl =
+      '^XA^FT100,200^A0R,30,0^FDA^FS^FO50,80^A0I,40,0^FDB^FS^XZ';
+    const { regenerated, second } = roundtrip(inputZpl);
+    // Second-pass parse of the regenerated ZPL must produce the same
+    // objects (obj.x/y unchanged) as the first.
+    const { first } = roundtrip(inputZpl);
+    expect(second.objects.map((o) => [o.x, o.y])).toEqual(
+      first.objects.map((o) => [o.x, o.y]),
+    );
+    expect(regenerated).toContain('^FT100,200');
+    expect(regenerated).toContain('^FO50,80');
+  });
+});
+
 describe('parseZPL — real-world structural commands are silently ignored', () => {
   // Labels produced by Zebra Designer / ZPL II tools commonly begin with a
   // block of printer configuration commands that carry no canvas-design info.
diff --git a/tests/fixtures/labelary_text_default_images/h20_0.png b/tests/fixtures/labelary_text_default_images/h20_0.png
new file mode 100644
index 00000000..f0cea133
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_0.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h20_5.png b/tests/fixtures/labelary_text_default_images/h20_5.png
new file mode 100644
index 00000000..3d12eb02
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_5.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h20_9.png b/tests/fixtures/labelary_text_default_images/h20_9.png
new file mode 100644
index 00000000..f9299b13
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_9.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h20_A.png b/tests/fixtures/labelary_text_default_images/h20_A.png
new file mode 100644
index 00000000..ab0ff7c9
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_A.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h20_M.png b/tests/fixtures/labelary_text_default_images/h20_M.png
new file mode 100644
index 00000000..50bc5d34
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_M.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h20_W.png b/tests/fixtures/labelary_text_default_images/h20_W.png
new file mode 100644
index 00000000..e0f726e9
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_W.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h20_dot.png b/tests/fixtures/labelary_text_default_images/h20_dot.png
new file mode 100644
index 00000000..682e9fbf
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_dot.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h20_eq.png b/tests/fixtures/labelary_text_default_images/h20_eq.png
new file mode 100644
index 00000000..896a1338
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_eq.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h20_lcA.png b/tests/fixtures/labelary_text_default_images/h20_lcA.png
new file mode 100644
index 00000000..2df42545
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_lcA.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h20_lcI.png b/tests/fixtures/labelary_text_default_images/h20_lcI.png
new file mode 100644
index 00000000..2a9e2823
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_lcI.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h20_lcP.png b/tests/fixtures/labelary_text_default_images/h20_lcP.png
new file mode 100644
index 00000000..34972941
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_lcP.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h20_minus.png b/tests/fixtures/labelary_text_default_images/h20_minus.png
new file mode 100644
index 00000000..f1b10709
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h20_minus.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_0.png b/tests/fixtures/labelary_text_default_images/h30_0.png
new file mode 100644
index 00000000..345d62b7
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_0.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_5.png b/tests/fixtures/labelary_text_default_images/h30_5.png
new file mode 100644
index 00000000..de28a500
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_5.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_9.png b/tests/fixtures/labelary_text_default_images/h30_9.png
new file mode 100644
index 00000000..bbbb5b4c
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_9.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_A.png b/tests/fixtures/labelary_text_default_images/h30_A.png
new file mode 100644
index 00000000..a790f578
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_A.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_M.png b/tests/fixtures/labelary_text_default_images/h30_M.png
new file mode 100644
index 00000000..add5e64d
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_M.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_W.png b/tests/fixtures/labelary_text_default_images/h30_W.png
new file mode 100644
index 00000000..2cb32619
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_W.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_dot.png b/tests/fixtures/labelary_text_default_images/h30_dot.png
new file mode 100644
index 00000000..ba7b0b10
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_dot.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_eq.png b/tests/fixtures/labelary_text_default_images/h30_eq.png
new file mode 100644
index 00000000..fc6c3279
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_eq.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_lcA.png b/tests/fixtures/labelary_text_default_images/h30_lcA.png
new file mode 100644
index 00000000..0d5dd1e5
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_lcA.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_lcI.png b/tests/fixtures/labelary_text_default_images/h30_lcI.png
new file mode 100644
index 00000000..89e475da
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_lcI.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_lcP.png b/tests/fixtures/labelary_text_default_images/h30_lcP.png
new file mode 100644
index 00000000..d1a852ba
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_lcP.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_minus.png b/tests/fixtures/labelary_text_default_images/h30_minus.png
new file mode 100644
index 00000000..6547508b
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_minus.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h30_w60_alpha.png b/tests/fixtures/labelary_text_default_images/h30_w60_alpha.png
new file mode 100644
index 00000000..35f16e90
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h30_w60_alpha.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h39_w57_long.png b/tests/fixtures/labelary_text_default_images/h39_w57_long.png
new file mode 100644
index 00000000..2f1f6f5d
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h39_w57_long.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_0.png b/tests/fixtures/labelary_text_default_images/h50_0.png
new file mode 100644
index 00000000..7cc3909e
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_0.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_5.png b/tests/fixtures/labelary_text_default_images/h50_5.png
new file mode 100644
index 00000000..7184fee7
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_5.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_9.png b/tests/fixtures/labelary_text_default_images/h50_9.png
new file mode 100644
index 00000000..251ec045
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_9.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_A.png b/tests/fixtures/labelary_text_default_images/h50_A.png
new file mode 100644
index 00000000..24fd570c
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_A.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_M.png b/tests/fixtures/labelary_text_default_images/h50_M.png
new file mode 100644
index 00000000..e89fe73e
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_M.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_W.png b/tests/fixtures/labelary_text_default_images/h50_W.png
new file mode 100644
index 00000000..e04f1b51
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_W.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_dot.png b/tests/fixtures/labelary_text_default_images/h50_dot.png
new file mode 100644
index 00000000..74290ccb
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_dot.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_eq.png b/tests/fixtures/labelary_text_default_images/h50_eq.png
new file mode 100644
index 00000000..0faeaf34
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_eq.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_lcA.png b/tests/fixtures/labelary_text_default_images/h50_lcA.png
new file mode 100644
index 00000000..57b0df8b
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_lcA.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_lcI.png b/tests/fixtures/labelary_text_default_images/h50_lcI.png
new file mode 100644
index 00000000..bd4dfe17
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_lcI.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_lcP.png b/tests/fixtures/labelary_text_default_images/h50_lcP.png
new file mode 100644
index 00000000..4a4b5d82
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_lcP.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_minus.png b/tests/fixtures/labelary_text_default_images/h50_minus.png
new file mode 100644
index 00000000..b5ff53b4
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_minus.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h50_w30_num.png b/tests/fixtures/labelary_text_default_images/h50_w30_num.png
new file mode 100644
index 00000000..9060375f
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h50_w30_num.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_0.png b/tests/fixtures/labelary_text_default_images/h80_0.png
new file mode 100644
index 00000000..e112a829
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_0.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_5.png b/tests/fixtures/labelary_text_default_images/h80_5.png
new file mode 100644
index 00000000..5d2a6c7a
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_5.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_9.png b/tests/fixtures/labelary_text_default_images/h80_9.png
new file mode 100644
index 00000000..0d005684
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_9.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_A.png b/tests/fixtures/labelary_text_default_images/h80_A.png
new file mode 100644
index 00000000..b36a403c
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_A.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_M.png b/tests/fixtures/labelary_text_default_images/h80_M.png
new file mode 100644
index 00000000..ae534f03
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_M.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_W.png b/tests/fixtures/labelary_text_default_images/h80_W.png
new file mode 100644
index 00000000..95bfeb15
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_W.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_dot.png b/tests/fixtures/labelary_text_default_images/h80_dot.png
new file mode 100644
index 00000000..ae91c855
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_dot.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_eq.png b/tests/fixtures/labelary_text_default_images/h80_eq.png
new file mode 100644
index 00000000..e44a2364
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_eq.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_lcA.png b/tests/fixtures/labelary_text_default_images/h80_lcA.png
new file mode 100644
index 00000000..ec570022
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_lcA.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_lcI.png b/tests/fixtures/labelary_text_default_images/h80_lcI.png
new file mode 100644
index 00000000..ef662c17
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_lcI.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_lcP.png b/tests/fixtures/labelary_text_default_images/h80_lcP.png
new file mode 100644
index 00000000..6e237ee8
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_lcP.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h80_minus.png b/tests/fixtures/labelary_text_default_images/h80_minus.png
new file mode 100644
index 00000000..b6b98271
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h80_minus.png differ
diff --git a/tests/fixtures/labelary_text_default_images/h87_w72_201.png b/tests/fixtures/labelary_text_default_images/h87_w72_201.png
new file mode 100644
index 00000000..f37651ea
Binary files /dev/null and b/tests/fixtures/labelary_text_default_images/h87_w72_201.png differ
diff --git a/tests/fixtures/labelary_text_images/h20_n_num.png b/tests/fixtures/labelary_text_images/h20_n_num.png
new file mode 100644
index 00000000..2aef4d3a
Binary files /dev/null and b/tests/fixtures/labelary_text_images/h20_n_num.png differ
diff --git a/tests/fixtures/labelary_text_images/h30_n_alpha.png b/tests/fixtures/labelary_text_images/h30_n_alpha.png
new file mode 100644
index 00000000..a4f43a9e
Binary files /dev/null and b/tests/fixtures/labelary_text_images/h30_n_alpha.png differ
diff --git a/tests/fixtures/labelary_text_images/h30_n_date.png b/tests/fixtures/labelary_text_images/h30_n_date.png
new file mode 100644
index 00000000..444234e8
Binary files /dev/null and b/tests/fixtures/labelary_text_images/h30_n_date.png differ
diff --git a/tests/fixtures/labelary_text_images/h30_n_decimal.png b/tests/fixtures/labelary_text_images/h30_n_decimal.png
new file mode 100644
index 00000000..c0104bdd
Binary files /dev/null and b/tests/fixtures/labelary_text_images/h30_n_decimal.png differ
diff --git a/tests/fixtures/labelary_text_images/h30_n_num.png b/tests/fixtures/labelary_text_images/h30_n_num.png
new file mode 100644
index 00000000..f9385069
Binary files /dev/null and b/tests/fixtures/labelary_text_images/h30_n_num.png differ
diff --git a/tests/fixtures/labelary_text_images/h39_n_long.png b/tests/fixtures/labelary_text_images/h39_n_long.png
new file mode 100644
index 00000000..e05cc267
Binary files /dev/null and b/tests/fixtures/labelary_text_images/h39_n_long.png differ
diff --git a/tests/fixtures/labelary_text_images/h50_n_num.png b/tests/fixtures/labelary_text_images/h50_n_num.png
new file mode 100644
index 00000000..ebd43ed4
Binary files /dev/null and b/tests/fixtures/labelary_text_images/h50_n_num.png differ
diff --git a/tests/fixtures/labelary_text_images/h80_n_alpha.png b/tests/fixtures/labelary_text_images/h80_n_alpha.png
new file mode 100644
index 00000000..75a4663e
Binary files /dev/null and b/tests/fixtures/labelary_text_images/h80_n_alpha.png differ
diff --git a/tests/fixtures/labelary_text_images/h80_n_num.png b/tests/fixtures/labelary_text_images/h80_n_num.png
new file mode 100644
index 00000000..29cbddb5
Binary files /dev/null and b/tests/fixtures/labelary_text_images/h80_n_num.png differ
diff --git a/tests/fixtures/textBoxMatchCases.ts b/tests/fixtures/textBoxMatchCases.ts
new file mode 100644
index 00000000..fe2b1539
--- /dev/null
+++ b/tests/fixtures/textBoxMatchCases.ts
@@ -0,0 +1,82 @@
+/** Box-match regression cases.
+ *
+ *  Compares our local @napi-rs/canvas render (using PrintLab ZPL) to
+ *  Labelary's DEFAULT-font render (CG Triumvirate via ^A0) — the same
+ *  output that lands on the user's printer. This is the gate for "will
+ *  the printed bbox match what the editor showed?", independent of
+ *  whether the user embeds our custom font in their ZPL.
+ *
+ *  Pattern is `char × 3` at multiple sizes so each diagnostic case has
+ *  enough glyphs to surface per-char advance drift without amplifying
+ *  string-specific kerning artefacts.
+ *
+ *  Sizes cover the common label range: 20 (small fineprint) through 80
+ *  (header text). Skipping intermediate sizes here keeps the fixture
+ *  set focused. */
+export interface TextBoxMatchCase {
+  id: string;
+  fontHeight: number;
+  /** Width parameter of `^A0,h,w`. 0 = use height (Zebra default).
+   *  Anything else stretches each glyph horizontally by w/h. */
+  fontWidth: number;
+  text: string;
+  rotation: 'N';
+  x: number;
+  y: number;
+}
+
+const SIZES = [20, 30, 50, 80];
+
+const CHARS = [
+  // Digits: most common label content, all should share the same
+  // advance class in CG Triumvirate.
+  '0', '5', '9',
+  // Alpha caps: spans narrow ('I') / medium ('A') / wide ('W').
+  'A', 'M', 'W',
+  // Lowercase: includes a descender ('p') for vertical reach checks.
+  'a', 'i', 'p',
+  // Punctuation Zebra renders unusually wide (hyphen and equals each
+  // got advance = 72 vs. our digits at 38) — these are the classes
+  // most likely to drift if hmtx stays out of sync with the live font.
+  '-', '.', '=',
+];
+
+/** Build a filesystem-safe id segment for `char`. NTFS / macOS HFS+
+ *  default to case-insensitive filenames, so `A` and `a` would collide
+ *  as fixture PNGs. Prefix lowercase ASCII letters with `lc` to keep
+ *  the test ids one-to-one with their files. */
+function charSlug(c: string): string {
+  if (c === '-') return 'minus';
+  if (c === '.') return 'dot';
+  if (c === '=') return 'eq';
+  if (c >= 'a' && c <= 'z') return `lc${c.toUpperCase()}`;
+  return c;
+}
+
+const uniformCases: TextBoxMatchCase[] = SIZES.flatMap((h) =>
+  CHARS.map((c) => ({
+    id: `h${String(h).padStart(2, '0')}_${charSlug(c)}`,
+    fontHeight: h,
+    fontWidth: 0,
+    text: c.repeat(3),
+    rotation: 'N' as const,
+    x: 200,
+    y: 200,
+  })),
+);
+
+/** Stretched cases: `^A0,h,w` with w != h. Mirrors the configurations
+ *  seen in real ZPL imports (e.g. ^A0N,87,72 from shipping labels).
+ *  Each pair runs both axes so a regression in scaleX direction is
+ *  caught at width-narrower and width-wider configurations. */
+const stretchedCases: TextBoxMatchCase[] = [
+  { id: 'h87_w72_201',  fontHeight: 87, fontWidth: 72, text: '201',          rotation: 'N', x: 200, y: 200 },
+  { id: 'h39_w57_long', fontHeight: 39, fontWidth: 57, text: '160940002422', rotation: 'N', x: 200, y: 200 },
+  { id: 'h50_w30_num',  fontHeight: 50, fontWidth: 30, text: '12345',        rotation: 'N', x: 200, y: 200 },
+  { id: 'h30_w60_alpha', fontHeight: 30, fontWidth: 60, text: 'ABC',          rotation: 'N', x: 200, y: 200 },
+];
+
+export const textBoxMatchCases: TextBoxMatchCase[] = [
+  ...uniformCases,
+  ...stretchedCases,
+];
diff --git a/tests/fixtures/textTestCases.ts b/tests/fixtures/textTestCases.ts
new file mode 100644
index 00000000..33695598
--- /dev/null
+++ b/tests/fixtures/textTestCases.ts
@@ -0,0 +1,43 @@
+/** Text-only visual regression cases. Compared against Labelary with our
+ *  uploaded custom font (R:PRINTLAB.TTF) so both sides use the same
+ *  glyph data — the residual diff is just anti-aliasing edge noise
+ *  between Labelary's renderer and Skia/@napi-rs/canvas. */
+export interface TextTestCase {
+  /** Unique id; doubles as the PNG filename stem under tests/fixtures/
+   *  labelary_text_images/. */
+  id: string;
+  /** ZPL font height in dots (the `h` param of ^A0/^A@). */
+  fontHeight: number;
+  /** Character data passed to `^FD`. Keep to printable ASCII; the
+   *  fixture renderer doesn't apply ^CI. */
+  text: string;
+  /** ZPL rotation. Mostly N for the first batch; rotated cases will
+   *  come once we trust the unrotated baseline. */
+  rotation: 'N' | 'R' | 'I' | 'B';
+  /** ^FO origin within the 4x4 inch (812×812 px @ 8 dpmm) canvas the
+   *  fetch script renders. Pick a value that keeps the rendered bbox
+   *  well inside the canvas at every test fontHeight + rotation. */
+  x: number;
+  y: number;
+}
+
+export const textTestCases: TextTestCase[] = [
+  // Size sweep with numeric content (the most common label payload).
+  { id: 'h20_n_num',     fontHeight: 20, text: '12345',        rotation: 'N', x: 200, y: 200 },
+  { id: 'h30_n_num',     fontHeight: 30, text: '12345',        rotation: 'N', x: 200, y: 200 },
+  { id: 'h50_n_num',     fontHeight: 50, text: '12345',        rotation: 'N', x: 200, y: 200 },
+  { id: 'h80_n_num',     fontHeight: 80, text: '12345',        rotation: 'N', x: 200, y: 200 },
+
+  // Alphabet caps — different glyph mix than digits.
+  { id: 'h30_n_alpha',   fontHeight: 30, text: 'ABCDEF',       rotation: 'N', x: 200, y: 200 },
+  { id: 'h80_n_alpha',   fontHeight: 80, text: 'ABCDEF',       rotation: 'N', x: 200, y: 200 },
+
+  // Long numeric (barcode-payload-shaped) — width accumulates per-char
+  // rounding error if any.
+  { id: 'h39_n_long',    fontHeight: 39, text: '160940002422', rotation: 'N', x: 200, y: 200 },
+
+  // Mixed content: digits + punctuation. Our font has special advance
+  // widths for dot/hyphen, so this exercises the hmtx table.
+  { id: 'h30_n_decimal', fontHeight: 30, text: '12.34',        rotation: 'N', x: 200, y: 200 },
+  { id: 'h30_n_date',    fontHeight: 30, text: '2026-05-15',   rotation: 'N', x: 200, y: 200 },
+];
diff --git a/tests/scripts/fetch_labelary_default_text_fixtures.ts b/tests/scripts/fetch_labelary_default_text_fixtures.ts
new file mode 100644
index 00000000..dce40cb1
--- /dev/null
+++ b/tests/scripts/fetch_labelary_default_text_fixtures.ts
@@ -0,0 +1,64 @@
+/*
+ * Generates Labelary reference PNGs rendered with the DEFAULT Zebra
+ * font (^A0, CG Triumvirate Condensed Bold) for the box-match test
+ * suite. No custom font is uploaded — the printer-resident font is
+ * what end users actually print with, so this is the ground truth for
+ * "what will land on the label".
+ *
+ * Run: npx --yes tsx tests/scripts/fetch_labelary_default_text_fixtures.ts
+ *
+ * Skips cases whose fixture already exists, so re-runs only fill gaps.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { textBoxMatchCases } from '../fixtures/textBoxMatchCases';
+
+const FIXTURES_DIR = path.resolve('tests/fixtures/labelary_text_default_images');
+const RENDER_URL = 'http://api.labelary.com/v1/printers/8dpmm/labels/4x4/0/';
+const RATE_LIMIT_MS = 1000;
+
+async function fetchLabel(zpl: string): Promise<Buffer> {
+  const res = await fetch(RENDER_URL, {
+    method: 'POST',
+    headers: {
+      Accept: 'image/png',
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: zpl,
+  });
+  if (!res.ok) {
+    throw new Error(`Labelary ${res.status}: ${await res.text()}`);
+  }
+  return Buffer.from(await res.arrayBuffer());
+}
+
+async function main(): Promise<void> {
+  fs.mkdirSync(FIXTURES_DIR, { recursive: true });
+
+  const missing = textBoxMatchCases.filter(
+    (tc) => !fs.existsSync(path.join(FIXTURES_DIR, `${tc.id}.png`)),
+  );
+  if (missing.length === 0) {
+    console.log('All fixtures already present.');
+    return;
+  }
+  console.log(`Fetching ${missing.length} fixture(s) with default Zebra font...`);
+
+  for (const tc of missing) {
+    const zpl =
+      `^XA^FO${tc.x},${tc.y}` +
+      `^A0${tc.rotation},${tc.fontHeight},${tc.fontWidth || tc.fontHeight}` +
+      `^FD${tc.text}^FS^XZ`;
+    const png = await fetchLabel(zpl);
+    fs.writeFileSync(path.join(FIXTURES_DIR, `${tc.id}.png`), png);
+    console.log(`  ${tc.id}.png`);
+    await new Promise((r) => setTimeout(r, RATE_LIMIT_MS));
+  }
+
+  console.log(`\nWrote ${missing.length} fixture(s) to ${FIXTURES_DIR}`);
+}
+
+main().catch((e: unknown) => {
+  console.error(e);
+  process.exit(1);
+});
diff --git a/tests/scripts/fetch_labelary_text_fixtures.ts b/tests/scripts/fetch_labelary_text_fixtures.ts
new file mode 100644
index 00000000..5254fdb9
--- /dev/null
+++ b/tests/scripts/fetch_labelary_text_fixtures.ts
@@ -0,0 +1,100 @@
+/*
+ * Generates the Labelary reference PNGs for the text visual-regression
+ * suite.
+ *
+ * Workflow:
+ *   1. Upload src/assets/fonts/PrintLabZPL-Bold.ttf to Labelary's
+ *      /v1/fonts endpoint. The response is ZPL `~DU` commands that
+ *      register the font under printer path R:PRINTLAB.TTF.
+ *   2. For every entry in tests/fixtures/textTestCases.ts, build a
+ *      ZPL label that references the uploaded font via `^A@...,R:PRINTLAB.TTF`
+ *      and renders it on a 4×4 inch 8-dpmm canvas.
+ *   3. Save the resulting PNG to tests/fixtures/labelary_text_images/.
+ *
+ * The test (src/test/textVisualRegression.test.ts) compares each
+ * fixture against a local @napi-rs/canvas render of the same content
+ * using the same TTF. With both sides loading the identical font, the
+ * remaining pixel diff is anti-aliasing noise — small enough to use
+ * as a reliable regression signal.
+ *
+ * Run: npx --yes tsx tests/scripts/fetch_labelary_text_fixtures.ts
+ *
+ * The script skips test cases whose fixture PNG already exists, so
+ * re-runs only fetch new entries.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { textTestCases } from '../fixtures/textTestCases';
+
+const FONT_PATH = path.resolve('src/assets/fonts/PrintLabZPL-Bold.ttf');
+const FIXTURES_DIR = path.resolve('tests/fixtures/labelary_text_images');
+const FONT_UPLOAD_URL = 'http://api.labelary.com/v1/fonts';
+const RENDER_URL = 'http://api.labelary.com/v1/printers/8dpmm/labels/4x4/0/';
+const RATE_LIMIT_MS = 1000;
+
+async function uploadFont(): Promise<string> {
+  const file = fs.readFileSync(FONT_PATH);
+  const form = new FormData();
+  form.append('file', new Blob([file]), 'PrintLabZPL.ttf');
+  form.append('path', 'R:PRINTLAB.TTF');
+  console.log(`Uploading ${FONT_PATH} (${file.length} bytes) to Labelary...`);
+  const res = await fetch(FONT_UPLOAD_URL, { method: 'POST', body: form });
+  if (!res.ok) {
+    throw new Error(`Font upload ${res.status}: ${await res.text()}`);
+  }
+  const zpl = await res.text();
+  console.log(`Got ${zpl.length} chars of ~DU font-download ZPL back.`);
+  return zpl;
+}
+
+async function fetchLabel(zpl: string): Promise<Buffer> {
+  const res = await fetch(RENDER_URL, {
+    method: 'POST',
+    headers: {
+      Accept: 'image/png',
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: zpl,
+  });
+  if (!res.ok) {
+    throw new Error(`Labelary ${res.status}: ${await res.text()}`);
+  }
+  return Buffer.from(await res.arrayBuffer());
+}
+
+async function main(): Promise<void> {
+  fs.mkdirSync(FIXTURES_DIR, { recursive: true });
+
+  // Decide upfront which cases are still missing — saves one font
+  // upload if everything is already cached.
+  const missing = textTestCases.filter(
+    (tc) => !fs.existsSync(path.join(FIXTURES_DIR, `${tc.id}.png`)),
+  );
+  if (missing.length === 0) {
+    console.log('All fixtures already present. Nothing to fetch.');
+    return;
+  }
+  console.log(`Need to fetch ${missing.length} fixture(s).`);
+
+  const fontDownloadZpl = await uploadFont();
+  await new Promise((r) => setTimeout(r, RATE_LIMIT_MS));
+
+  for (const tc of missing) {
+    const zpl =
+      `^XA${fontDownloadZpl}^FO${tc.x},${tc.y}` +
+      `^A@${tc.rotation},${tc.fontHeight},${tc.fontHeight},R:PRINTLAB.TTF` +
+      `^FD${tc.text}^FS^XZ`;
+    const png = await fetchLabel(zpl);
+    const outPath = path.join(FIXTURES_DIR, `${tc.id}.png`);
+    fs.writeFileSync(outPath, png);
+    console.log(`  ${tc.id}.png  (${png.length} bytes)`);
+    await new Promise((r) => setTimeout(r, RATE_LIMIT_MS));
+  }
+
+  console.log(`\nWrote ${missing.length} fixture(s) to ${FIXTURES_DIR}`);
+}
+
+main().catch((e: unknown) => {
+  console.error(e);
+  process.exit(1);
+});