fix(v1): preserve nested content-control parent topology (#1105)

* fix(v1): preserve nested content-control parent topology

* test(v1): strengthen nested SDT round-trip coverage

Ported-From-Source-Repo: superdoc/orbit
Ported-From-Source-Commit: 5a7401384e0d2dc0a6bdfd1375bb45614b2eb91b
Ported-Public-Prefix: superdoc/public

Author: tupizz

packages/super-editor/src/editors/v1/document-api-adapters/plan-engine/content-controls-wrappers.ts

@@ -470,7 +470,10 @@ function getParentWrapper(editor: Editor, input: ContentControlsGetParentInput):
   const sdt = resolveSdtByTarget(editor.state.doc, input.target);
   const $pos = editor.state.doc.resolve(sdt.pos);
 
-  for (let depth = $pos.depth - 1; depth >= 0; depth--) {
+  // `sdt.pos` points immediately before the target node. At that boundary,
+  // `$pos.depth` is already the depth of the containing node, so skipping it
+  // misses the direct parent for nested SDTs.
+  for (let depth = $pos.depth; depth >= 0; depth--) {
     const ancestor = $pos.node(depth);
     if (isSdtNode(ancestor)) {
       return buildContentControlInfoFromNode({

packages/super-editor/src/editors/v1/document-api-adapters/plan-engine/sd-3617-content-control-wrap-persistence.integration.test.ts

@@ -0,0 +1,93 @@
+/* @vitest-environment jsdom */
+
+import { describe, expect, it } from 'vitest';
+import { Editor } from '../../core/Editor.js';
+import { initTestEditor, loadTestDataForEditorTests } from '../../tests/helpers/helpers.js';
+
+type LoadedDocData = Awaited<ReturnType<typeof loadTestDataForEditorTests>>;
+
+function openEditor(docData: LoadedDocData) {
+  return initTestEditor({
+    content: docData.docx,
+    media: docData.media,
+    mediaFiles: docData.mediaFiles,
+    fonts: docData.fonts,
+    useImmediateSetTimeout: false,
+    isHeadless: true,
+    user: { name: 'Test', email: 'test@example.com' },
+  }).editor;
+}
+
+async function reopenEditor(editor: Editor) {
+  const exported = await editor.exportDocx();
+  const bytes = exported instanceof Uint8Array ? exported : new Uint8Array(exported);
+  const [docx, media, mediaFiles, fonts] = await Editor.loadXmlData(bytes, true);
+  return openEditor({ docx, media, mediaFiles, fonts });
+}
+
+describe('SD-3617 nested content-control wrap persistence', () => {
+  it('contentControls.wrap persists a real parent around an existing block SDT after save and reopen', async () => {
+    const source = await loadTestDataForEditorTests('sdt-nested-block.docx');
+    const editor = openEditor(source);
+    let reopened: Editor | undefined;
+    try {
+      const child = editor.doc.contentControls.selectByTag({ tag: 'outer-block' }).items[0]!;
+      const result = editor.doc.contentControls.wrap({
+        target: child.target,
+        kind: 'block',
+        tag: 'sdk-parent',
+        alias: 'SDK parent',
+      });
+
+      expect(result.success).toBe(true);
+      if (!result.success || !result.updatedRef) {
+        throw new Error('Expected contentControls.wrap to return the persisted parent reference');
+      }
+      expect(editor.doc.contentControls.get({ target: result.updatedRef }).properties.tag).toBe('sdk-parent');
+      reopened = await reopenEditor(editor);
+
+      const reopenedChild = reopened.doc.contentControls.selectByTag({ tag: 'outer-block' }).items[0]!;
+      const reopenedParent = reopened.doc.contentControls.get({ target: result.updatedRef });
+
+      expect(reopenedChild.id).toBe(child.id);
+      expect(reopenedParent.properties.tag).toBe('sdk-parent');
+      expect(reopened.doc.contentControls.getParent({ target: reopenedChild.target })?.id).toBe(reopenedParent.id);
+      expect(
+        reopened.doc.contentControls.listChildren({ target: reopenedParent.target }).items.map(({ id }) => id),
+      ).toEqual([reopenedChild.id]);
+    } finally {
+      reopened?.destroy();
+      editor.destroy();
+    }
+  });
+
+  it('contentControls.group.wrap persists a group parent around an existing block SDT after save and reopen', async () => {
+    const source = await loadTestDataForEditorTests('sdt-nested-block.docx');
+    const editor = openEditor(source);
+    let reopened: Editor | undefined;
+    try {
+      const child = editor.doc.contentControls.selectByTag({ tag: 'outer-block' }).items[0]!;
+      const result = editor.doc.contentControls.group.wrap({ target: child.target });
+
+      expect(result.success).toBe(true);
+      if (!result.success || !result.updatedRef) {
+        throw new Error('Expected contentControls.group.wrap to return the persisted parent reference');
+      }
+      expect(editor.doc.contentControls.get({ target: result.updatedRef }).controlType).toBe('group');
+      reopened = await reopenEditor(editor);
+
+      const reopenedParent = reopened.doc.contentControls.get({ target: result.updatedRef });
+      const reopenedChild = reopened.doc.contentControls.selectByTag({ tag: 'outer-block' }).items[0]!;
+      expect(reopenedChild.id).toBe(child.id);
+      expect(reopenedParent.controlType).toBe('group');
+      expect(reopenedParent.id).toBe(result.updatedRef.nodeId);
+      expect(reopened.doc.contentControls.getParent({ target: reopenedChild.target })?.id).toBe(reopenedParent.id);
+      expect(
+        reopened.doc.contentControls.listChildren({ target: reopenedParent.target }).items.map(({ id }) => id),
+      ).toEqual([reopenedChild.id]);
+    } finally {
+      reopened?.destroy();
+      editor.destroy();
+    }
+  });
+});