From a1e81231ca11868103dc120189329fe47ee2349b Mon Sep 17 00:00:00 2001
From: u8array <alexanderleinich1@gmail.com>
Date: Fri, 15 May 2026 09:29:45 +0200
Subject: [PATCH] refactor(groups): post-merge cleanup bundle

Three independent follow-up threads from the groups feature merge:

* refactor(types): move `LabelObject` from `registry/index.ts` to
  `types/Group.ts`. Breaks the type-only cycle where registry
  imported `GroupObject` only to compose `LabelObject`, which
  `types/Group` then imported back. Now one-way: `types/Group`
  depends on registry for `LeafObject`. About 25 consumer imports
  updated.

* fix(store): cascade lock through ancestor groups in
  `applyObjectChanges`. `updateObject` reads ancestor state once via
  `findAncestors`; `updateObjects` carries `inheritedLocked` through
  the recursive walk. Load-bearing, because `expandSelection`-driven
  flows (arrow-key nudges, multi-drag) previously sidestepped a
  locked group by targeting its leaf children directly. Bypass keys
  (locked, visible, includeInExport, comment, name) still pass so
  the layers panel can release the cascade.

* refactor(design-file): split `labelObjectSchema` into discriminated
  leaf / group shapes (leaf requires `props`, group requires
  `children`). Adds a round-trip test for nested groups plus
  negative cases for malformed leaves and groups.

Also drops the dead `inheritedHidden` walk parameter in
`LabelCanvas.visibleLeaves` (early-continue meant it never
propagated) and aligns the new cascade tests with the `isGroup`-
narrowing pattern used elsewhere in `labelStore.test.ts`.
---
 src/components/Canvas/ImageObject.tsx         |  2 +-
 src/components/Canvas/LabelCanvas.tsx         | 15 ++--
 src/components/Canvas/LineObject.tsx          |  2 +-
 src/components/Canvas/bwipHelpers.ts          |  3 +-
 src/components/Canvas/hooks/useCanvasLasso.ts |  3 +-
 .../Canvas/transformPosition.test.ts          |  2 +-
 src/components/Canvas/transformPosition.ts    |  3 +-
 src/components/Properties/LayerRow.tsx        |  3 +-
 src/components/Properties/useLayerDnd.ts      |  3 +-
 src/lib/designFile.test.ts                    | 73 ++++++++++++++++++-
 src/lib/designFile.ts                         | 27 +++++--
 src/lib/printPreview.ts                       |  2 +-
 src/lib/shapeRender.ts                        |  2 +-
 src/lib/zplGenerator.test.ts                  |  3 +-
 src/lib/zplGenerator.ts                       |  3 +-
 src/lib/zplImportService.ts                   |  2 +-
 src/lib/zplParser.ts                          |  2 +-
 src/registry/index.ts                         | 10 +--
 src/registry/line.test.ts                     |  2 +-
 src/store/labelStore.test.ts                  | 42 ++++++++++-
 src/store/labelStore.ts                       | 50 +++++++++----
 src/test/testModels.ts                        |  2 +-
 src/types/Group.test.ts                       |  2 +-
 src/types/Group.ts                            | 10 ++-
 tests/fixtures/shapeTestCases.ts              |  2 +-
 25 files changed, 205 insertions(+), 65 deletions(-)

diff --git a/src/components/Canvas/ImageObject.tsx b/src/components/Canvas/ImageObject.tsx
index 3e1391a6..7a30ed49 100644
--- a/src/components/Canvas/ImageObject.tsx
+++ b/src/components/Canvas/ImageObject.tsx
@@ -1,7 +1,7 @@
 import { useState, useEffect, useRef } from "react";
 import { Group, Image as KImage, Rect, Text } from "react-konva";
 import type Konva from "konva";
-import type { LabelObject } from "../../registry";
+import type { LabelObject } from "../../types/Group";
 import { dotsToPx, pxToDots } from "../../lib/coordinates";
 import { getImage } from "../../lib/imageCache";
 import { useColorScheme } from "../../lib/useColorScheme";
diff --git a/src/components/Canvas/LabelCanvas.tsx b/src/components/Canvas/LabelCanvas.tsx
index 9459a055..0aa8a6a6 100644
--- a/src/components/Canvas/LabelCanvas.tsx
+++ b/src/components/Canvas/LabelCanvas.tsx
@@ -13,7 +13,7 @@ import type { PaletteDragData } from "../../dnd/types";
 import { Stage, Layer, Group, Rect, Transformer } from "react-konva";
 import type Konva from "konva";
 import { useLabelStore, useCurrentObjects, currentObjects, getCurrentObjects } from "../../store/labelStore";
-import { isGroup, getAllLeaves, expandSelection, selectionTargetId, findObjectById } from "../../types/Group";
+import { isGroup, getAllLeaves, expandSelection, selectionTargetId, findObjectById, type LabelObject } from "../../types/Group";
 import { pxToDots, SCREEN_PX_PER_MM } from "../../lib/coordinates";
 import { SNAP_OPTIONS } from "../../lib/units";
 import type { Unit } from "../../lib/units";
@@ -26,7 +26,7 @@ import { Grid } from "./Grid";
 import { GuideLines } from "./GuideLines";
 import { Ruler, RULER_SIZE } from "./Ruler";
 import { ObjectRegistry } from "../../registry";
-import type { LabelObject, LeafObject } from "../../registry";
+import type { LeafObject } from "../../registry";
 import { useColorScheme } from "../../lib/useColorScheme";
 import { objectIdsAtPoint } from "./hitTesting";
 import { useT } from "../../lib/useT";
@@ -131,21 +131,18 @@ export const LabelCanvas = forwardRef<LabelCanvasHandle, Props>(function LabelCa
   // without each consumer having to walk ancestors.
   const visibleLeaves = useMemo(() => {
     const out: LeafObject[] = [];
-    const walk = (nodes: LabelObject[], inheritedLocked: boolean, inheritedHidden: boolean) => {
+    const walk = (nodes: LabelObject[], inheritedLocked: boolean) => {
       for (const n of nodes) {
+        if (n.visible === false) continue;
         const locked = inheritedLocked || !!n.locked;
-        const hidden = inheritedHidden || n.visible === false;
-        if (hidden) continue;
         if (isGroup(n)) {
-          walk(n.children, locked, hidden);
+          walk(n.children, locked);
         } else {
-          // Preserve object identity when nothing was inherited so React
-          // memoisation keeps unaffected leaves stable across renders.
           out.push(locked && !n.locked ? ({ ...n, locked: true } as LeafObject) : n);
         }
       }
     };
-    walk(objects, false, false);
+    walk(objects, false);
     return out;
   }, [objects]);
 
diff --git a/src/components/Canvas/LineObject.tsx b/src/components/Canvas/LineObject.tsx
index 297f3547..6d6f6cfd 100644
--- a/src/components/Canvas/LineObject.tsx
+++ b/src/components/Canvas/LineObject.tsx
@@ -1,7 +1,7 @@
 import { useRef, useState } from "react";
 import { Group, Line as KLine, Rect } from "react-konva";
 import type Konva from "konva";
-import type { LabelObject } from "../../registry";
+import type { LabelObject } from "../../types/Group";
 import { dotsToPx, pxToDots } from "../../lib/coordinates";
 import { constrainLine, type ConstrainMode } from "../../lib/lineConstrain";
 import { useColorScheme } from "../../lib/useColorScheme";
diff --git a/src/components/Canvas/bwipHelpers.ts b/src/components/Canvas/bwipHelpers.ts
index f38d705b..70b3a499 100644
--- a/src/components/Canvas/bwipHelpers.ts
+++ b/src/components/Canvas/bwipHelpers.ts
@@ -12,7 +12,8 @@
  * bwipHelpers.test.ts ensures every BCID-registered type has a case.
  */
 
-import type { LabelObject, LeafObject } from "../../registry";
+import type { LeafObject } from "../../registry";
+import type { LabelObject } from "../../types/Group";
 import type { Gs1DatabarProps } from "../../registry/gs1databar";
 import { objectRotation } from "../../registry/rotation";
 import { dotsToPx } from "../../lib/coordinates";
diff --git a/src/components/Canvas/hooks/useCanvasLasso.ts b/src/components/Canvas/hooks/useCanvasLasso.ts
index 062849c1..3c0cac55 100644
--- a/src/components/Canvas/hooks/useCanvasLasso.ts
+++ b/src/components/Canvas/hooks/useCanvasLasso.ts
@@ -1,8 +1,7 @@
 import { useState, useRef } from "react";
 import type Konva from "konva";
 import { getCurrentObjects } from "../../../store/labelStore";
-import type { LabelObject } from "../../../registry";
-import { isGroup } from "../../../types/Group";
+import { isGroup, type LabelObject } from "../../../types/Group";
 import { getIdsIntersectingRect, type LassoRect } from "../lassoGeometry";
 
 interface Options {
diff --git a/src/components/Canvas/transformPosition.test.ts b/src/components/Canvas/transformPosition.test.ts
index cfb78fd7..c9430fef 100644
--- a/src/components/Canvas/transformPosition.test.ts
+++ b/src/components/Canvas/transformPosition.test.ts
@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { modelPositionFromRenderedTopLeft } from "./transformPosition";
 import { QR_FO_Y_OFFSET_DOTS } from "./bwipConstants";
-import type { LabelObject } from "../../registry";
+import type { LabelObject } from "../../types/Group";
 
 const qrFo: LabelObject = {
   id: "q1",
diff --git a/src/components/Canvas/transformPosition.ts b/src/components/Canvas/transformPosition.ts
index 08b30ffd..cbbca324 100644
--- a/src/components/Canvas/transformPosition.ts
+++ b/src/components/Canvas/transformPosition.ts
@@ -1,4 +1,5 @@
-import { BARCODE_1D_TYPES, type LabelObject } from "../../registry";
+import { BARCODE_1D_TYPES } from "../../registry";
+import type { LabelObject } from "../../types/Group";
 import { QR_FO_Y_OFFSET_DOTS } from "./bwipConstants";
 
 /**
diff --git a/src/components/Properties/LayerRow.tsx b/src/components/Properties/LayerRow.tsx
index b6b33494..b8d58659 100644
--- a/src/components/Properties/LayerRow.tsx
+++ b/src/components/Properties/LayerRow.tsx
@@ -10,8 +10,7 @@ import {
   LinkSlashIcon,
 } from '@heroicons/react/16/solid';
 import { ObjectRegistry } from '../../registry';
-import type { LabelObject } from '../../registry';
-import { isGroup } from '../../types/Group';
+import { isGroup, type LabelObject } from '../../types/Group';
 import { useT } from '../../lib/useT';
 import { DragHandleIcon } from '../ui/DragHandleIcon';
 import { INDENT_STEP } from './layerLayout';
diff --git a/src/components/Properties/useLayerDnd.ts b/src/components/Properties/useLayerDnd.ts
index 3964ec82..246b6d98 100644
--- a/src/components/Properties/useLayerDnd.ts
+++ b/src/components/Properties/useLayerDnd.ts
@@ -2,8 +2,7 @@ import { useEffect, useMemo, useRef, useState } from 'react';
 import { PointerSensor, closestCenter, useSensor, useSensors } from '@dnd-kit/core';
 import type { DragEndEvent, DragOverEvent } from '@dnd-kit/core';
 import { isGroup, findObjectById, findAncestors } from '../../types/Group';
-import type { GroupObject } from '../../types/Group';
-import type { LabelObject } from '../../registry';
+import type { GroupObject, LabelObject } from '../../types/Group';
 import { INDENT_STEP } from './layerLayout';
 
 /** Sentinel container id for the top-level objects list. Group containers
diff --git a/src/lib/designFile.test.ts b/src/lib/designFile.test.ts
index 6eb44a55..8bce73c5 100644
--- a/src/lib/designFile.test.ts
+++ b/src/lib/designFile.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { parseDesignFile, serializeDesign } from './designFile';
-import type { LabelObject } from '../registry';
+import type { LabelObject } from '../types/Group';
 
 const SAMPLE_OBJECTS: LabelObject[] = [
   {
@@ -85,4 +85,75 @@ describe('parseDesignFile', () => {
     expect(result.value.pages[0]?.objects).toHaveLength(1);
     expect(result.value.pages[1]?.objects).toHaveLength(1);
   });
+
+  it('roundtrips a design containing nested groups without structural loss', () => {
+    const designWithGroups: LabelObject[] = [
+      SAMPLE_OBJECTS[0]!,
+      {
+        id: 'grp-outer',
+        type: 'group',
+        x: 0,
+        y: 0,
+        rotation: 0,
+        name: 'Header',
+        children: [
+          {
+            id: 'grp-inner',
+            type: 'group',
+            x: 0,
+            y: 0,
+            rotation: 0,
+            children: [
+              {
+                id: 'obj-2',
+                type: 'box',
+                x: 5,
+                y: 5,
+                rotation: 0,
+                props: { width: 20, height: 10, thickness: 1, filled: true, color: 'B', rounding: 0 },
+              },
+            ],
+          } as LabelObject,
+        ],
+      } as LabelObject,
+    ];
+    const json = serializeDesign(
+      { widthMm: 100, heightMm: 60, dpmm: 8 },
+      [{ objects: designWithGroups }],
+    );
+    const result = parseDesignFile(json);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.pages[0]?.objects).toEqual(designWithGroups);
+  });
+
+  it('rejects a leaf object that is missing its props', () => {
+    const malformed = JSON.stringify({
+      label: { widthMm: 100, heightMm: 60, dpmm: 8 },
+      pages: [
+        {
+          objects: [{ id: 'a', type: 'box', x: 0, y: 0, rotation: 0 }],
+        },
+      ],
+    });
+    const result = parseDesignFile(malformed);
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error).toBe('invalid_schema');
+  });
+
+  it('rejects a group object that is missing its children', () => {
+    const malformed = JSON.stringify({
+      label: { widthMm: 100, heightMm: 60, dpmm: 8 },
+      pages: [
+        {
+          objects: [{ id: 'g', type: 'group', x: 0, y: 0, rotation: 0 }],
+        },
+      ],
+    });
+    const result = parseDesignFile(malformed);
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error).toBe('invalid_schema');
+  });
 });
diff --git a/src/lib/designFile.ts b/src/lib/designFile.ts
index 33aa36e6..fda43583 100644
--- a/src/lib/designFile.ts
+++ b/src/lib/designFile.ts
@@ -1,23 +1,34 @@
 import { z } from "zod";
 import { labelConfigSchema, labelObjectBaseSchema, type LabelConfig } from "../types/ObjectType";
-import type { LabelObject } from "../registry";
+import type { LabelObject } from "../types/Group";
 import { ok, err, type Result } from "./result";
 
 export type DesignFileError = "parse_error" | "invalid_schema";
 export interface DesignFilePage { objects: LabelObject[] }
 export interface DesignFile { label: LabelConfig; pages: DesignFilePage[] }
 
-// Leaves carry `props`; groups carry `children` instead and skip `props`.
-// Both shapes share the base fields. `children` is recursive so the
-// validator descends into nested groups too — the lazy wrap is what
-// lets the schema reference itself.
-const labelObjectSchema: z.ZodType<unknown> = z.lazy(() =>
+// Two distinct shapes share the base fields:
+//   * leaves carry `props` and have no `children`,
+//   * groups carry `children` and have no `props` (their `type` is 'group').
+// Split into separate schemas so a leaf missing its `props` or a group
+// missing its `children` fails validation. `groupSchema` is wrapped in
+// z.lazy so the recursion through `labelObjectSchema` resolves.
+const leafSchema = labelObjectBaseSchema.extend({
+  type: z.string().refine((t) => t !== 'group', {
+    message: "Leaf objects cannot have type 'group'",
+  }),
+  props: z.record(z.string(), z.unknown()),
+});
+
+const groupSchema: z.ZodType<unknown> = z.lazy(() =>
   labelObjectBaseSchema.extend({
-    props: z.record(z.string(), z.unknown()).optional(),
-    children: z.array(labelObjectSchema).optional(),
+    type: z.literal('group'),
+    children: z.array(labelObjectSchema),
   }),
 );
 
+const labelObjectSchema: z.ZodType<unknown> = z.union([groupSchema, leafSchema]);
+
 const pageSchema = z.object({ objects: z.array(labelObjectSchema) });
 
 const designFileSchema = z.object({
diff --git a/src/lib/printPreview.ts b/src/lib/printPreview.ts
index 36904252..e205c928 100644
--- a/src/lib/printPreview.ts
+++ b/src/lib/printPreview.ts
@@ -1,7 +1,7 @@
 import { generateZPL } from "./zplGenerator";
 import { fetchPreview } from "./labelary";
 import type { LabelConfig } from "../types/ObjectType";
-import type { LabelObject } from "../registry";
+import type { LabelObject } from "../types/Group";
 
 export function buildLoadingHtml(): string {
   return `<html><head><style>
diff --git a/src/lib/shapeRender.ts b/src/lib/shapeRender.ts
index a73bf5dc..62e41d39 100644
--- a/src/lib/shapeRender.ts
+++ b/src/lib/shapeRender.ts
@@ -1,4 +1,4 @@
-import type { LabelObject } from "../registry";
+import type { LabelObject } from "../types/Group";
 import { diagonalPolygonPoints } from "./shapeGeometry";
 
 /** Inward-extruded ^GE / ^GC ring or solid disc, shared by ellipse and
diff --git a/src/lib/zplGenerator.test.ts b/src/lib/zplGenerator.test.ts
index 9154be42..8b664ad6 100644
--- a/src/lib/zplGenerator.test.ts
+++ b/src/lib/zplGenerator.test.ts
@@ -2,8 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { generateZPL, generateMultiPageZPL } from './zplGenerator';
 import { parseZPL } from './zplParser';
 import type { LabelConfig } from '../types/ObjectType';
-import type { LabelObject } from '../registry';
-import type { GroupObject } from '../types/Group';
+import type { GroupObject, LabelObject } from '../types/Group';
 import { defined, props } from '../test/helpers';
 
 const BASE_LABEL: LabelConfig = {
diff --git a/src/lib/zplGenerator.ts b/src/lib/zplGenerator.ts
index b163e1f1..cb3c19c1 100644
--- a/src/lib/zplGenerator.ts
+++ b/src/lib/zplGenerator.ts
@@ -2,9 +2,8 @@ import { mmToDots } from './coordinates';
 import { ObjectRegistry } from '../registry';
 import { stripZplCommandChars } from '../registry/zplHelpers';
 import type { LabelConfig } from '../types/ObjectType';
-import type { LabelObject } from '../registry';
 import type { Page } from '../store/labelStore';
-import { isGroup } from '../types/Group';
+import { isGroup, type LabelObject } from '../types/Group';
 
 /**
  * Concatenates `generateZPL` output for every page. Each page becomes its own
diff --git a/src/lib/zplImportService.ts b/src/lib/zplImportService.ts
index 6e170000..db3f2ab9 100644
--- a/src/lib/zplImportService.ts
+++ b/src/lib/zplImportService.ts
@@ -1,6 +1,6 @@
 import { parseZPL, type ImportFinding, type ImportFindingKind, type ImportReport } from "./zplParser";
 import type { LabelConfig } from "../types/ObjectType";
-import type { LabelObject } from "../registry";
+import type { LabelObject } from "../types/Group";
 
 export interface ZplImportResult {
   labelConfig: Partial<LabelConfig>;
diff --git a/src/lib/zplParser.ts b/src/lib/zplParser.ts
index 3067452b..41464c33 100644
--- a/src/lib/zplParser.ts
+++ b/src/lib/zplParser.ts
@@ -1,5 +1,5 @@
 import type { LabelConfig } from "../types/ObjectType";
-import type { LabelObject } from "../registry";
+import type { LabelObject } from "../types/Group";
 import type { TextProps } from "../registry/text";
 import type { Code128Props } from "../registry/code128";
 import type { Code39Props } from "../registry/code39";
diff --git a/src/registry/index.ts b/src/registry/index.ts
index 5888bda8..7457cefd 100644
--- a/src/registry/index.ts
+++ b/src/registry/index.ts
@@ -1,5 +1,4 @@
 import type { ObjectTypeDefinition, LabelObjectBase } from '../types/ObjectType';
-import type { GroupObject } from '../types/Group';
 import { text } from './text.tsx';
 import type { TextProps } from './text.tsx';
 import { code128 } from './code128.tsx';
@@ -64,8 +63,8 @@ import { codablock } from './codablock.tsx';
 import type { CodablockProps } from './codablock.tsx';
 
 /** Leaf objects: every registry-backed type. These render to ZPL and
- *  have a PropertiesPanel. Groups (see `LabelObject`) are structural
- *  only and intentionally outside this union. */
+ *  have a PropertiesPanel. The tree-level union `LabelObject` (which
+ *  also covers `GroupObject`) lives in `types/Group.ts`. */
 export type LeafObject =
   | (LabelObjectBase & { type: 'text'; props: TextProps })
   | (LabelObjectBase & { type: 'code128'; props: Code128Props })
@@ -99,11 +98,6 @@ export type LeafObject =
   | (LabelObjectBase & { type: 'micropdf417'; props: MicroPdf417Props })
   | (LabelObjectBase & { type: 'codablock'; props: CodablockProps });
 
-/** Any node in the object tree: either a leaf (registry-backed) or a
- *  group container. Most code paths should operate on this; use
- *  `isGroup` from `types/Group` to narrow. */
-export type LabelObject = LeafObject | GroupObject;
-
 export const BARCODE_1D_TYPES = new Set([
   'code128', 'code39', 'ean13', 'ean8', 'upca', 'upce', 'interleaved2of5', 'code93',
   'code11', 'industrial2of5', 'standard2of5', 'codabar', 'logmars', 'msi', 'plessey',
diff --git a/src/registry/line.test.ts b/src/registry/line.test.ts
index 387bd910..c8d2f30c 100644
--- a/src/registry/line.test.ts
+++ b/src/registry/line.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 import { pickAngle, line } from "./line";
-import type { LabelObject } from "./index";
+import type { LabelObject } from "../types/Group";
 
 const makeLine = (overrides: Partial<{
   x: number; y: number; angle: number; length: number; thickness: number;
diff --git a/src/store/labelStore.test.ts b/src/store/labelStore.test.ts
index 67fa5c62..93468aff 100644
--- a/src/store/labelStore.test.ts
+++ b/src/store/labelStore.test.ts
@@ -1,7 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { useLabelStore, currentObjects } from './labelStore';
-import type { LabelObject } from '../registry';
-import { isGroup } from '../types/Group';
+import { isGroup, type LabelObject } from '../types/Group';
 import { defined, props } from '../test/helpers';
 
 /** Reset store to clean state before each test. */
@@ -814,4 +813,43 @@ describe('ungroup', () => {
     expect(objs()).toHaveLength(2);
     expect(objs().every((o) => !isGroup(o))).toBe(true);
   });
+
+  describe('lock cascade', () => {
+    /** Set up "one text leaf inside a locked group" and return the leaf id. */
+    function setupLockedGroup(): string {
+      state().addObject('text');
+      const leafId = defined(objs()[0]).id;
+      state().selectObject(leafId);
+      state().groupSelection();
+      const gid = defined(state().selectedIds[0]);
+      state().updateObject(gid, { locked: true });
+      return leafId;
+    }
+
+    function childLeaf(): LabelObject {
+      const g = defined(objs()[0]);
+      if (!isGroup(g)) throw new Error('expected group');
+      return defined(g.children[0]);
+    }
+
+    it('blocks position changes on a child of a locked group via updateObject', () => {
+      const leafId = setupLockedGroup();
+      const before = childLeaf().x;
+      state().updateObject(leafId, { x: before + 50 });
+      expect(childLeaf().x).toBe(before);
+    });
+
+    it('blocks position changes on a child of a locked group via updateObjects', () => {
+      const leafId = setupLockedGroup();
+      const before = childLeaf().x;
+      state().updateObjects([{ id: leafId, changes: { x: before + 50 } }]);
+      expect(childLeaf().x).toBe(before);
+    });
+
+    it('still allows bypass keys (visible, locked) on a child of a locked group', () => {
+      const leafId = setupLockedGroup();
+      state().updateObject(leafId, { visible: false });
+      expect(childLeaf().visible).toBe(false);
+    });
+  });
 });
diff --git a/src/store/labelStore.ts b/src/store/labelStore.ts
index 82d0cfd6..12474488 100644
--- a/src/store/labelStore.ts
+++ b/src/store/labelStore.ts
@@ -5,14 +5,15 @@ import type { LabelConfig, ObjectChanges } from '../types/ObjectType';
 import type { Unit } from '../lib/units';
 import type { ViewRotation } from '../components/Canvas/rotationGeometry';
 import { ObjectRegistry } from '../registry';
-import type { LabelObject } from '../registry';
 import {
   isGroup,
   mapObjectById,
   detachObjectById,
   findObjectById,
+  findAncestors,
   isSelfOrDescendant,
   type GroupObject,
+  type LabelObject,
 } from '../types/Group';
 import { locales } from '../locales';
 import type { LocaleCode } from '../locales';
@@ -34,8 +35,19 @@ function isLockBypass(changes: ObjectChanges): boolean {
   return keys.length > 0 && keys.every((k) => LOCK_BYPASS_KEYS.has(k));
 }
 
-function applyObjectChanges(obj: LabelObject, changes: ObjectChanges): LabelObject {
-  if (obj.locked && !isLockBypass(changes)) return obj;
+function applyObjectChanges(
+  obj: LabelObject,
+  changes: ObjectChanges,
+  ancestorLocked = false,
+): LabelObject {
+  // Lock cascades from any ancestor group: a leaf inside a locked group
+  // accepts only bypass keys (locked / visible / includeInExport /
+  // comment / name) so the user can still toggle visibility or release
+  // the lock from the layers panel. Load-bearing — `expandSelection`-
+  // driven callers (arrow-key nudges, shift-multi-drag) target the
+  // group's leaf children directly and would otherwise sidestep the
+  // group's own `locked` flag.
+  if ((obj.locked || ancestorLocked) && !isLockBypass(changes)) return obj;
   if (isGroup(obj)) {
     // Groups have no registry entry (no normalize hook) and no props to
     // merge — apply top-level changes only. Children stay untouched;
@@ -308,11 +320,15 @@ export const useLabelStore = create<LabelState>()(
       },
 
       updateObject: (id, changes) =>
-        set((state) =>
-          updateCurrentObjects(state, (objs) =>
-            mapObjectById(objs, id, (obj) => applyObjectChanges(obj, changes)),
-          ),
-        ),
+        set((state) => {
+          const objs = currentObjects(state);
+          const ancestorLocked = findAncestors(objs, id).some((g) => !!g.locked);
+          return updateCurrentObjects(state, (curr) =>
+            mapObjectById(curr, id, (obj) =>
+              applyObjectChanges(obj, changes, ancestorLocked),
+            ),
+          );
+        }),
 
       updateObjects: (updates) =>
         set((state) => {
@@ -320,15 +336,23 @@ export const useLabelStore = create<LabelState>()(
           // Single tree walk that applies every queued change in one
           // pass: O(tree) instead of O(updates × tree). Identity-
           // preserving — subtrees with no matching id keep their
-          // reference so React memoisation can skip them.
+          // reference so React memoisation can skip them. The walk
+          // carries inheritedLocked so a leaf inside a locked group
+          // sees the cascade without each call re-traversing ancestors.
           const updateMap = new Map(updates.map((u) => [u.id, u.changes]));
-          const applyUpdates = (nodes: LabelObject[]): LabelObject[] => {
+          const applyUpdates = (
+            nodes: LabelObject[],
+            inheritedLocked: boolean,
+          ): LabelObject[] => {
             let changed = false;
             const next = nodes.map((n) => {
               const changes = updateMap.get(n.id);
-              let updated = changes ? applyObjectChanges(n, changes) : n;
+              let updated = changes
+                ? applyObjectChanges(n, changes, inheritedLocked)
+                : n;
               if (isGroup(updated)) {
-                const nextChildren = applyUpdates(updated.children);
+                const childLocked = inheritedLocked || !!updated.locked;
+                const nextChildren = applyUpdates(updated.children, childLocked);
                 if (nextChildren !== updated.children) {
                   updated = { ...updated, children: nextChildren };
                 }
@@ -338,7 +362,7 @@ export const useLabelStore = create<LabelState>()(
             });
             return changed ? next : nodes;
           };
-          return updateCurrentObjects(state, (objs) => applyUpdates(objs));
+          return updateCurrentObjects(state, (objs) => applyUpdates(objs, false));
         }),
 
       removeObject: (id) =>
diff --git a/src/test/testModels.ts b/src/test/testModels.ts
index ea383d72..bfc57aef 100644
--- a/src/test/testModels.ts
+++ b/src/test/testModels.ts
@@ -1,4 +1,4 @@
-import type { LabelObject } from "../registry";
+import type { LabelObject } from "../types/Group";
 
 export const testModels: Record<string, LabelObject> = {
   barcode_code128_standard: {
diff --git a/src/types/Group.test.ts b/src/types/Group.test.ts
index 44c0066f..132aec83 100644
--- a/src/types/Group.test.ts
+++ b/src/types/Group.test.ts
@@ -12,8 +12,8 @@ import {
   canGroupSelection,
   mapObjectById,
   type GroupObject,
+  type LabelObject,
 } from './Group';
-import type { LabelObject } from '../registry';
 
 function leaf(id: string): LabelObject {
   // The tree helpers under test only inspect id / type / children, never
diff --git a/src/types/Group.ts b/src/types/Group.ts
index 3a9821de..48173ee3 100644
--- a/src/types/Group.ts
+++ b/src/types/Group.ts
@@ -1,4 +1,4 @@
-import type { LabelObject, LeafObject } from '../registry';
+import type { LeafObject } from '../registry';
 import type { LabelObjectBase } from './ObjectType';
 
 /**
@@ -16,6 +16,14 @@ export type GroupObject = LabelObjectBase & {
   children: LabelObject[];
 };
 
+/** Any node in the object tree: either a registry-backed leaf or a
+ *  structural group container. Most code paths operate on this; use
+ *  `isGroup` to narrow. Lives next to `GroupObject` (rather than next
+ *  to `LeafObject` in the registry) because the type composes the two
+ *  and the tree-walking helpers in this module are its primary
+ *  consumers — keeping it here breaks the registry ↔ types cycle. */
+export type LabelObject = LeafObject | GroupObject;
+
 export function isGroup(obj: LabelObject): obj is GroupObject {
   return obj.type === 'group';
 }
diff --git a/tests/fixtures/shapeTestCases.ts b/tests/fixtures/shapeTestCases.ts
index da714cbc..1cb88c2b 100644
--- a/tests/fixtures/shapeTestCases.ts
+++ b/tests/fixtures/shapeTestCases.ts
@@ -1,4 +1,4 @@
-import type { LabelObject } from "../../src/registry";
+import type { LabelObject } from "../../src/types/Group";
 
 /**
  * Pixel-regression cases for the geometric primitives (box, line, ellipse,