diff --git a/package-lock.json b/package-lock.json
index 25c7d13..393333d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "simulink-data-explorer",
-  "version": "1.2.13",
+  "version": "1.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "simulink-data-explorer",
-      "version": "1.2.13",
+      "version": "1.3.0",
       "license": "BSD-3-Clause",
       "dependencies": {
         "@lit/context": "^1.1.6",
diff --git a/package.json b/package.json
index a967bb1..535a0fb 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
   "name": "simulink-data-explorer",
   "displayName": "Simulink Data Explorer",
   "description": "Explore Simulink models, data dictionaries, MAT-files, and projects as interactive tables and relationship trees.",
-  "version": "1.2.13",
+  "version": "1.3.0",
   "publisher": "mathworks",
   "icon": "media/icon.png",
   "private": true,
diff --git a/src/dex/components/dex-tree-table.ts b/src/dex/components/dex-tree-table.ts
index 0e047f4..f0c5d60 100644
--- a/src/dex/components/dex-tree-table.ts
+++ b/src/dex/components/dex-tree-table.ts
@@ -3,6 +3,7 @@
 import { LitElement, html, css, nothing } from 'lit';
 import { customElement, property, state, query } from 'lit/decorators.js';
 import { highContrastStyles } from '../styles/high-contrast.styles.js';
+import { dragModeFromModifiers, type DragMode } from '../../webview/dragMode.js';
 import './dex-icon.js';
 
 export interface TreeTableRow {
@@ -376,6 +377,56 @@ export class DexTreeTable extends LitElement {
         border-radius: 2px;
       }
 
+      tr.data-row.drop-target-forbidden {
+        box-shadow: inset 0 0 0 2px var(--vscode-errorForeground, #f14c4c);
+        border-radius: 2px;
+        cursor: no-drop;
+      }
+
+      /* Floating drag tooltip that trails the cursor; fixed so it can overhang
+         the scroll container. Non-interactive so it never eats drag events. */
+      .drop-tooltip {
+        position: fixed;
+        z-index: 1000;
+        pointer-events: none;
+        display: flex;
+        align-items: center;
+        gap: 6px;
+        padding: 3px 8px;
+        font-size: 12px;
+        font-family: var(--vscode-font-family, system-ui, sans-serif);
+        color: var(--vscode-editorHoverWidget-foreground, #fff);
+        background: var(--vscode-editorHoverWidget-background, #252526);
+        border: 1px solid var(--vscode-editorHoverWidget-border, #454545);
+        border-radius: 3px;
+        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.25);
+        white-space: nowrap;
+        max-width: 360px;
+      }
+
+      .drop-tooltip.forbidden {
+        color: var(--vscode-errorForeground, #f14c4c);
+      }
+
+      .drop-tooltip-icon {
+        font-weight: bold;
+      }
+
+      /* The dragged row's name; the action text is dimmed and separated so the
+         box reads "[icon] Name — Move Bus" as one affordance. */
+      .drop-tooltip-name {
+        font-weight: 600;
+      }
+
+      .drop-tooltip-action {
+        opacity: 0.85;
+      }
+      /* Separator between the name and the action, only when a name precedes it. */
+      .drop-tooltip-name + .drop-tooltip-action::before {
+        content: '— ';
+        opacity: 0.6;
+      }
+
       td {
         padding: 3px 8px;
         border-right: 1px solid var(--dex-border-color-light, #e0e0e0);
@@ -563,6 +614,38 @@ export class DexTreeTable extends LitElement {
   @state() private _dragSourceId: string | null = null;
   @state() private _dropTargetId: string | null = null;
   @state() private _dropPosition: 'above' | 'on' | null = null;
+  // Live drop feedback driven by the injected dropPredictor: whether the row
+  // under the cursor rejects the drop, plus the hover tooltip ("Convert Bus to
+  // Data Interface" / "Simulink Parameter cannot be in Architectural Data") and
+  // its screen position. Empty tooltip renders nothing.
+  @state() private _dropForbidden = false;
+  @state() private _dropTooltip = '';
+  @state() private _dropTooltipX = 0;
+  @state() private _dropTooltipY = 0;
+  // The dragged row's icon + name, captured at drag start. They ride in the same
+  // floating box as the action text so there is ONE cursor affordance (icon +
+  // name + "Move/Copy…"), not a separate native ghost. For a multi-drag the
+  // count drives a "(+N)" suffix. Empty label = no active local drag.
+  @state() private _dragIconId = '';
+  @state() private _dragLabel = '';
+  @state() private _dragCount = 0;
+  // The copy/move mode observed on the LAST dragover. The `drop` event's modifier
+  // state (ctrlKey/metaKey) is unreliable on Chromium/macOS — it can read false
+  // even while Cmd is held — but dragover, which fires continuously, reports it
+  // correctly. So we stash it here on dragover and use it at drop time, keeping
+  // the completed action in sync with the "Move"/"Copy" the tooltip showed.
+  private _lastDragMode: 'copy' | 'move' = 'move';
+
+  // Predicts a drop for the row under the cursor, injected by the host-side glue
+  // (table-main) and backed by the pure dropDecision. Returns null when there is
+  // no active drag or the target can't be resolved, in which case the table
+  // falls back to its built-in permissive drag behavior.
+  @property({ attribute: false }) dropPredictor:
+    | ((
+        targetRowId: string,
+        mode: 'copy' | 'move',
+      ) => { canDrop: boolean; cursor: string; tooltip: string; noop: boolean } | null)
+    | null = null;
 
   @state() private _columnWidths: Map<string, number> = new Map();
   @state() private _columnOrder: string[] = [...DEFAULT_COLUMN_ORDER];
@@ -1425,98 +1508,159 @@ export class DexTreeTable extends LitElement {
 
   // --- Row Drag and Drop ---
 
-  private _onRowDragStart(rowId: string, e: DragEvent): void {
-    this._dragSourceId = rowId;
-    const rowIds =
-      this.selectedRowIds.length > 1 && this.selectedRowIds.includes(rowId) ? this.selectedRowIds : [rowId];
+  // The copy-vs-move modifier follows the platform convention (Option on macOS,
+  // Ctrl elsewhere); see dragMode.ts for why matching the OS key is required. The
+  // mapping lives there as a pure, unit-tested function; this just supplies the
+  // live platform + modifier state.
+  private _dragModeFrom(e: DragEvent | MouseEvent): DragMode {
+    return dragModeFromModifiers(navigator.platform, { altKey: e.altKey, ctrlKey: e.ctrlKey });
+  }
 
-    const classNames: string[] = [];
-    for (const id of rowIds) {
-      const row = this.rows.find((r) => r.ID === id);
-      if (row) {
-        const dt = typeof row.DataType === 'object' ? row.DataType.text : String(row.DataType || '');
-        if (dt) classNames.push(dt);
-      }
+  private _onRowDragStart(rowId: string, e: DragEvent): void {
+    // Section headers aren't draggable entries. If the grabbed row is a header,
+    // there's nothing to drag; otherwise drag the multi-selection (when the
+    // grabbed row is part of it) or just the grabbed row, minus any headers.
+    if (rowId.indexOf('section:') === 0) {
+      e.preventDefault();
+      return;
     }
+    this._dragSourceId = rowId;
+    this._lastDragMode = 'move';
+    const rowIds = (
+      this.selectedRowIds.length > 1 && this.selectedRowIds.includes(rowId) ? this.selectedRowIds : [rowId]
+    ).filter((id) => id.indexOf('section:') !== 0);
 
     if (e.dataTransfer) {
       e.dataTransfer.effectAllowed = 'copyMove';
-      e.dataTransfer.setData('application/dex-rows', JSON.stringify({ rowIds, classNames }));
+      // A payload is still set so the browser treats this as a real drag across
+      // the webview boundary, but the authoritative source lives in the host
+      // drag register (dataTransfer doesn't reliably survive the boundary).
+      e.dataTransfer.setData('application/dex-rows', JSON.stringify({ rowIds }));
       this._setDragImage(e, rowId, rowIds.length);
     }
     this.dispatchEvent(
       new CustomEvent('dex-row-drag-start', {
-        detail: { rowIds, classNames },
+        detail: { rowIds },
         bubbles: true,
         composed: true,
       }),
     );
   }
 
+  // Capture the dragged row's icon + name into state (so the single floating box
+  // in _renderDropTooltip can show them alongside the action text) and SUPPRESS
+  // the browser's native drag image, so there is exactly one affordance at the
+  // cursor rather than two overlapping boxes. The native image is replaced with a
+  // 1x1 transparent pixel positioned off the cursor.
   private _setDragImage(e: DragEvent, rowId: string, count: number): void {
     const row = this.rows.find((r) => r.ID === rowId);
     if (!row || !e.dataTransfer) return;
+    this._dragIconId = row.Name?.iconId || '';
+    this._dragLabel = row.Name?.label || rowId;
+    this._dragCount = count;
 
-    const ghost = document.createElement('div');
-    ghost.style.cssText =
-      'position:absolute;top:-1000px;left:-1000px;display:flex;align-items:center;gap:6px;padding:4px 10px;background:#fff;border:1px solid #d0d0d0;border-radius:4px;font-size:12px;font-family:system-ui,sans-serif;box-shadow:0 2px 8px rgba(0,0,0,.15);white-space:nowrap;';
-    const iconId = row.Name?.iconId;
-    if (iconId) {
-      const icon = document.createElement('dex-icon') as HTMLElement;
-      (icon as unknown as { iconId: string }).iconId = iconId;
-      (icon as unknown as { size: number }).size = 16;
-      ghost.appendChild(icon);
-    }
-    const label = document.createElement('span');
-    label.textContent = count > 1 ? `${row.Name?.label || rowId} (+${count - 1})` : row.Name?.label || rowId;
-    ghost.appendChild(label);
-    document.body.appendChild(ghost);
-    e.dataTransfer.setDragImage(ghost, 0, 0);
-    requestAnimationFrame(() => document.body.removeChild(ghost));
+    // A 1x1 transparent image hides the native ghost without cancelling the drag.
+    const blank = new Image();
+    blank.src =
+      'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
+    e.dataTransfer.setDragImage(blank, -10, -10);
   }
 
   private _onRowDragEnd(_e: DragEvent): void {
     this._dragSourceId = null;
     this._dropTargetId = null;
     this._dropPosition = null;
+    this._dropForbidden = false;
+    this._dropTooltip = '';
+    this._dragIconId = '';
+    this._dragLabel = '';
+    this._dragCount = 0;
+    // Tell the host the drag is over so it can clear the register + broadcast.
+    this.dispatchEvent(new CustomEvent('dex-row-drag-end', { bubbles: true, composed: true }));
   }
 
   private _onRowDragOver(rowId: string, e: DragEvent): void {
-    if (rowId === this._dragSourceId) return;
+    // Keep the floating affordance trailing the cursor even over the source row
+    // (where the drop itself is a no-op) so the icon + name box never freezes.
+    this._dropTooltipX = e.clientX;
+    this._dropTooltipY = e.clientY;
+    if (rowId === this._dragSourceId) {
+      // Over the drag origin the drop is a no-op; show just the icon + name (no
+      // action verb) and don't accept a drop here.
+      this._dropTooltip = '';
+      this._dropForbidden = false;
+      return;
+    }
+    const mode = this._dragModeFrom(e);
+    // Remember the mode from this dragover; the drop event can't read it reliably.
+    this._lastDragMode = mode;
+
+    // Ask the injected predictor whether this drop is allowed and what to show.
+    // With no predictor (or no active drag it recognizes), fall back to the
+    // built-in permissive behavior so drag still works without the host glue.
+    const decision = this.dropPredictor ? this.dropPredictor(rowId, mode) : null;
+    if (decision) {
+      this._dropTargetId = rowId;
+      this._dropPosition = 'on';
+      this._dropForbidden = !decision.canDrop;
+      this._dropTooltip = decision.tooltip;
+      this._dropTooltipX = e.clientX;
+      this._dropTooltipY = e.clientY;
+      if (decision.canDrop) {
+        // A droppable target must preventDefault so the browser fires `drop`.
+        e.preventDefault();
+        if (e.dataTransfer) e.dataTransfer.dropEffect = decision.cursor === 'copy' ? 'copy' : 'move';
+      } else if (e.dataTransfer) {
+        // Not droppable: leave the drop un-accepted (no preventDefault) and show
+        // the no-drop cursor. A no-op (same-section move) reads as "none" too.
+        e.dataTransfer.dropEffect = 'none';
+      }
+      return;
+    }
+
     e.preventDefault();
     if (e.dataTransfer) {
-      e.dataTransfer.dropEffect = e.ctrlKey || e.metaKey ? 'copy' : 'move';
+      e.dataTransfer.dropEffect = mode;
     }
     this._dropTargetId = rowId;
     this._dropPosition = 'on';
+    this._dropForbidden = false;
+    this._dropTooltip = '';
   }
 
   private _onRowDragLeave(_e: DragEvent): void {
     this._dropTargetId = null;
     this._dropPosition = null;
+    this._dropForbidden = false;
+    this._dropTooltip = '';
   }
 
   private _onRowDrop(targetRowId: string, e: DragEvent): void {
     e.preventDefault();
     e.stopPropagation();
 
-    const data = e.dataTransfer?.getData('application/dex-rows');
-    if (!data) return;
+    // Use the mode from the last dragover, not the drop event: Chromium/macOS
+    // often reports the modifier as released on `drop`, which would silently
+    // downgrade a Cmd-drag Copy to a Move. dragover tracked it correctly.
+    const mode = this._lastDragMode;
 
-    const { rowIds } = JSON.parse(data);
-    const isCopy = e.ctrlKey || e.metaKey;
+    // Respect the predictor: never complete a rejected or no-op drop. The drag
+    // may have started in ANOTHER webview, so the source rows come from the host
+    // drag register, not local dataTransfer (which doesn't cross the boundary) —
+    // the drop event only needs to carry the target + mode.
+    const decision = this.dropPredictor ? this.dropPredictor(targetRowId, mode) : null;
 
     this._dragSourceId = null;
     this._dropTargetId = null;
     this._dropPosition = null;
+    this._dropForbidden = false;
+    this._dropTooltip = '';
+
+    if (decision && !decision.canDrop) return;
 
     this.dispatchEvent(
       new CustomEvent('dex-row-drop', {
-        detail: {
-          sourceRowIds: rowIds,
-          targetRowId,
-          mode: isCopy ? 'copy' : 'move',
-        },
+        detail: { targetRowId, mode },
         bubbles: true,
         composed: true,
       }),
@@ -2143,7 +2287,9 @@ export class DexTreeTable extends LitElement {
                     'copy'
                       ? 'copied'
                       : ''} ${isDragSource ? 'drag-source' : ''} ${isDropTarget && this._dropPosition === 'on'
-                      ? 'drop-target-on'
+                      ? this._dropForbidden
+                        ? 'drop-target-forbidden'
+                        : 'drop-target-on'
                       : ''} ${isDropTarget && this._dropPosition === 'above' ? 'drop-target-above' : ''}"
                     data-row-id="${row.ID}"
                     draggable="true"
@@ -2173,10 +2319,37 @@ export class DexTreeTable extends LitElement {
           </table>
         </div>
       </div>
-      ${this._renderColumnMenu()}
+      ${this._renderColumnMenu()} ${this._renderDropTooltip()}
     `;
   }
 
+  // The floating drag tooltip that follows the cursor while dragging, describing
+  // what the drop will do ("Convert Bus to Data Interface") or why it can't
+  // ("Simulink Parameter cannot be in Architectural Data"). Rendered only while a
+  // predictor has produced a tooltip; the forbidden variant is styled distinctly.
+  private _renderDropTooltip() {
+    // One floating affordance at the cursor: the dragged row's icon + name (from
+    // drag start) plus the live action text ("Move Bus", "Convert …", or the
+    // forbidden reason). Shown whenever a local drag carries a label, so the box
+    // is visible even before the cursor reaches a droppable row. A cross-tab drag
+    // has no local label here, so it only appears once over this table (with the
+    // action text and no icon), which is the expected behavior.
+    const hasLabel = !!this._dragLabel;
+    if (!hasLabel && !this._dropTooltip) return html``;
+    const countSuffix = this._dragCount > 1 ? ` (+${this._dragCount - 1})` : '';
+    return html`<div
+      class="drop-tooltip ${this._dropForbidden ? 'forbidden' : ''}"
+      style="left:${this._dropTooltipX + 14}px; top:${this._dropTooltipY + 16}px"
+    >
+      ${this._dropForbidden ? html`<span class="drop-tooltip-icon">⊘</span>` : ''}${this._dragIconId
+        ? html`<dex-icon class="drop-tooltip-row-icon" .iconId=${this._dragIconId} .size=${14}></dex-icon>`
+        : ''}${hasLabel ? html`<span class="drop-tooltip-name">${this._dragLabel}${countSuffix}</span>` : ''}${this
+        ._dropTooltip
+        ? html`<span class="drop-tooltip-action">${this._dropTooltip}</span>`
+        : ''}
+    </div>`;
+  }
+
   private _renderColumnsButton() {
     return html`
       <button
diff --git a/src/dex/datamodel/kindMap.ts b/src/dex/datamodel/kindMap.ts
new file mode 100644
index 0000000..83b6309
--- /dev/null
+++ b/src/dex/datamodel/kindMap.ts
@@ -0,0 +1,92 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// The Class → user-facing Kind mapping, factored out of DataNode so it has NO
+// model dependencies and can be bundled into the webview (the drag/drop tooltip
+// needs human-readable Kind labels — "Bus", "Data Interface" — without a live
+// model). Pure data + one pure function; safe on both host and client.
+
+// The user-facing Kind for each object Class. This is the friendly name shown in
+// the Kind column (e.g. Class 'Simulink.Bus' → Kind 'Bus'); it never appears in
+// the Class column (raw class identity) or the Data Type column (a real data
+// type). A class absent from this map falls back to its raw class name.
+export const KIND_BY_CLASS: Record<string, string> = {
+  'Simulink.Parameter': 'Simulink Parameter',
+  'Simulink.Signal': 'Simulink Signal',
+  'Simulink.LookupTable': 'Lookup Table',
+  'Simulink.Breakpoint': 'Breakpoint',
+  'Simulink.Bus': 'Bus',
+  'Simulink.BusElement': 'Bus Element',
+  'Simulink.ConnectionBus': 'Connection Bus',
+  'Simulink.ConnectionElement': 'Connection Element',
+  'Simulink.ServiceBus': 'Service Interface',
+  'Simulink.FunctionElement': 'Function Element',
+  'Simulink.ValueType': 'Value Type',
+  'Simulink.AliasType': 'Alias Type',
+  'Simulink.NumericType': 'Numeric Type',
+  'Simulink.data.dictionary.EnumTypeDefinition': 'Enumerated Type',
+  'Simulink.VariantExpression': 'Variant Expression',
+  'Simulink.VariantControl': 'Variant Control',
+  'Simulink.VariantVariable': 'Variant Variable',
+  'Simulink.VariantBank': 'Variant Bank',
+  'Simulink.VariantBankCoderInfo': 'Variant Bank Coder Info',
+  'Simulink.VariantConfigurationData': 'Variant Configuration',
+  'Simulink.VariantConfigurations': 'Variant Configuration',
+  'Simulink.ConfigSet': 'Configuration Set',
+  'Simulink.ConfigSetRef': 'Configuration Reference',
+};
+
+// The default user-facing Kind for a DERIVED (architectural) entry when the
+// SystemComposer catalog doesn't classify it — e.g. a freshly pasted entry, whose
+// new name isn't in the catalog. Architectural data stores interfaces as ordinary
+// Simulink objects, so the same Class means a different Kind there: a derived
+// Simulink.Bus is a Data Interface, a derived Simulink.ConnectionBus a Physical
+// Interface. Classes whose Kind is identical in both sections (e.g.
+// Simulink.ServiceBus → 'Service Interface', value/numeric/alias types) are
+// omitted — KIND_BY_CLASS already yields the right label for them.
+export const DERIVED_KIND_BY_CLASS: Record<string, string> = {
+  'Simulink.Bus': 'Data Interface',
+  'Simulink.ConnectionBus': 'Physical Interface',
+};
+
+// The user-facing Kind for each semantic classification token. Some entries are
+// classified (via the systemcomposer catalog) into a Kind that comes from the
+// classification rather than the Class, so the same Simulink.Bus can be a 'Data
+// Interface' or a 'Struct Type' depending on how the catalog models it.
+export const KIND_BY_CLASSIFICATION: Record<string, string> = {
+  DataInterface: 'Data Interface',
+  PhysicalInterface: 'Physical Interface',
+  ServiceInterface: 'Service Interface',
+  ValueType: 'Value Type',
+  StructType: 'Struct Type',
+  NumericType: 'Numeric Type',
+  EnumType: 'Enumerated Type',
+  AliasType: 'Alias Type',
+};
+
+// The Kind a plain MATLAB variable (className 'double', 'int8', a struct, etc.)
+// shows: 'MATLAB Variable' in Design Data, 'Constant' when derived (arch). A
+// MATLAB variable has no entry in KIND_BY_CLASS (its className is a raw data
+// type), so this is handled separately from the object-class path.
+export function matlabVariableKind(isDerived: boolean): string {
+  return isDerived ? 'Constant' : 'MATLAB Variable';
+}
+
+// Resolve the user-facing Kind for a Class in a given section context, WITHOUT a
+// live node — used by the webview drag/drop tooltip. `classification` (when the
+// catalog classified the source) wins; then a derived object class takes its arch
+// default; else the plain class map; else the raw class name. `isMatlabVariable`
+// routes 'double'/struct/etc. through matlabVariableKind. Mirrors DataNode.kind
+// and MatlabVariableNode.kind so the tooltip label matches the Kind column.
+export function kindForClass(
+  className: string,
+  opts: { isDerived?: boolean; isMatlabVariable?: boolean; classification?: string } = {},
+): string {
+  const { isDerived = false, isMatlabVariable = false, classification } = opts;
+  if (isMatlabVariable) {
+    if (classification) return KIND_BY_CLASSIFICATION[classification] || classification;
+    return matlabVariableKind(isDerived);
+  }
+  if (classification) return KIND_BY_CLASSIFICATION[classification] || classification;
+  if (isDerived && DERIVED_KIND_BY_CLASS[className]) return DERIVED_KIND_BY_CLASS[className];
+  return KIND_BY_CLASS[className] || className;
+}
diff --git a/src/dex/datamodel/node/DataNode.ts b/src/dex/datamodel/node/DataNode.ts
index 368b444..d6577f7 100644
--- a/src/dex/datamodel/node/DataNode.ts
+++ b/src/dex/datamodel/node/DataNode.ts
@@ -1,6 +1,7 @@
 // Copyright 2026 The MathWorks, Inc.
 
 import BaseNode from './BaseNode';
+import { KIND_BY_CLASS, DERIVED_KIND_BY_CLASS, KIND_BY_CLASSIFICATION } from '../kindMap';
 import {
   escapeXml,
   formatDoubleXml,
@@ -57,65 +58,6 @@ export interface SetPropertyResult {
   validValue: string;
 }
 
-// The user-facing Kind for each object Class. This is the friendly name shown
-// in the Kind column (e.g. Class 'Simulink.Bus' → Kind 'Bus'); it never appears
-// in the Class column (which shows the raw class identity) or the Data Type
-// column (which shows a real data type). A class absent from this map falls back
-// to its raw class name as its Kind.
-const KIND_BY_CLASS: Record<string, string> = {
-  'Simulink.Parameter': 'Simulink Parameter',
-  'Simulink.Signal': 'Simulink Signal',
-  'Simulink.LookupTable': 'Lookup Table',
-  'Simulink.Breakpoint': 'Breakpoint',
-  'Simulink.Bus': 'Bus',
-  'Simulink.BusElement': 'Bus Element',
-  'Simulink.ConnectionBus': 'Connection Bus',
-  'Simulink.ConnectionElement': 'Connection Element',
-  'Simulink.ServiceBus': 'Service Interface',
-  'Simulink.FunctionElement': 'Function Element',
-  'Simulink.ValueType': 'Value Type',
-  'Simulink.AliasType': 'Alias Type',
-  'Simulink.NumericType': 'Numeric Type',
-  'Simulink.data.dictionary.EnumTypeDefinition': 'Enumerated Type',
-  'Simulink.VariantExpression': 'Variant Expression',
-  'Simulink.VariantControl': 'Variant Control',
-  'Simulink.VariantVariable': 'Variant Variable',
-  'Simulink.VariantBank': 'Variant Bank',
-  'Simulink.VariantBankCoderInfo': 'Variant Bank Coder Info',
-  'Simulink.VariantConfigurationData': 'Variant Configuration',
-  'Simulink.VariantConfigurations': 'Variant Configuration',
-  'Simulink.ConfigSet': 'Configuration Set',
-  'Simulink.ConfigSetRef': 'Configuration Reference',
-};
-
-// The default user-facing Kind for a DERIVED (architectural) entry when the
-// SystemComposer catalog doesn't classify it — e.g. a freshly pasted entry,
-// whose new name isn't in the catalog. Architectural data stores interfaces as
-// ordinary Simulink objects, so the same Class means a different Kind there: a
-// derived Simulink.Bus is a Data Interface, a derived Simulink.ConnectionBus a
-// Physical Interface. Classes whose Kind is identical in both sections (e.g.
-// Simulink.ServiceBus -> 'Service Interface', value/numeric/alias types) are
-// omitted — KIND_BY_CLASS already yields the right label for them.
-const DERIVED_KIND_BY_CLASS: Record<string, string> = {
-  'Simulink.Bus': 'Data Interface',
-  'Simulink.ConnectionBus': 'Physical Interface',
-};
-
-// The user-facing Kind for each semantic classification token. Some entries are
-// classified (via the systemcomposer catalog) into a Kind that comes from the
-// classification rather than the Class, so the same Simulink.Bus can be a
-// 'Data Interface' or a 'Struct Type' depending on how the catalog models it.
-const KIND_BY_CLASSIFICATION: Record<string, string> = {
-  DataInterface: 'Data Interface',
-  PhysicalInterface: 'Physical Interface',
-  ServiceInterface: 'Service Interface',
-  ValueType: 'Value Type',
-  StructType: 'Struct Type',
-  NumericType: 'Numeric Type',
-  EnumType: 'Enumerated Type',
-  AliasType: 'Alias Type',
-};
-
 export default class DataNode extends BaseNode {
   metadata: Record<string, unknown> | null;
   serial: Record<string, unknown>;
diff --git a/src/dex/datamodel/node/data/MatlabVariableNode.ts b/src/dex/datamodel/node/data/MatlabVariableNode.ts
index 52611c0..b9b1adb 100644
--- a/src/dex/datamodel/node/data/MatlabVariableNode.ts
+++ b/src/dex/datamodel/node/data/MatlabVariableNode.ts
@@ -2,6 +2,7 @@
 
 import DataNode from '../DataNode';
 import type { SetPropertyResult } from '../DataNode';
+import { matlabVariableKind } from '../../kindMap';
 import type { PropClass } from '../BaseNode';
 import type BaseNode from '../BaseNode';
 import * as NodeRegistry from '../NodeRegistry';
@@ -283,7 +284,7 @@ export default class MatlabVariableNode extends DataNode {
     if (this.classification) {
       return super.kind;
     }
-    return this.isDerived ? 'Constant' : 'MATLAB Variable';
+    return matlabVariableKind(this.isDerived);
   }
 
   get nameEditable(): boolean {
diff --git a/src/host/SlddTextEditorProvider.ts b/src/host/SlddTextEditorProvider.ts
index 289639d..b0fed0d 100644
--- a/src/host/SlddTextEditorProvider.ts
+++ b/src/host/SlddTextEditorProvider.ts
@@ -3,14 +3,18 @@ import * as vscode from 'vscode';
 import { renderWebviewHtml } from './webviewHtml.js';
 import { getModel, invalidate, findNode } from './SlddModel.js';
 import { findEntrySpan, detectIndent } from './entrySplice.js';
-import { buildRows, COLUMNS, COLUMN_LABELS } from './rowBuilder.js';
+import { buildRows, COLUMNS, COLUMN_LABELS, type ClipMark } from './rowBuilder.js';
 import { captureBaseline, computeModified, clearBaseline } from './slddBaseline.js';
 import { setClipboard, getClipboard, clearClipboard, clipboardState } from './clipboard.js';
+import { setDrag, getDrag, clearDrag, dragDescriptor, type DragRegisterItem } from './dragState.js';
+import { sectionRules } from './sectionRules.js';
 import {
   deleteEntry,
   deleteChild,
   addChild as addChildEdit,
   pasteEntry,
+  pasteEntries,
+  deleteEntriesByName,
   findOwningEntry,
   resolveSectionForPaste,
   reserializeEntry,
@@ -31,17 +35,34 @@ import { onNavigateSelect, consumePendingSelect } from './navigate.js';
 export class SlddTextEditorProvider implements vscode.CustomTextEditorProvider {
   public static readonly viewType = 'dataExplorer.tableView';
 
-  // Every live table webview, so a copy/cut/clear in ONE editor can push the new
-  // clipboard state to ALL of them. The host clipboard is a single shared
-  // singleton (clipboard.ts), but each webview caches its own `canPaste` flag to
-  // build the menu synchronously — without this broadcast, a second already-open
-  // .sldd would never learn the clipboard now has content, so its Paste stays
-  // disabled and pasting across files silently does nothing.
-  private static readonly liveWebviews = new Set<vscode.Webview>();
+  // Every live table webview mapped to its repaint callback, so a copy/cut/
+  // clear/paste in ONE editor can update ALL of them. The host clipboard is a
+  // single shared singleton (clipboard.ts), but each webview caches its own
+  // `canPaste` flag to build the menu synchronously — without this broadcast, a
+  // second already-open .sldd would never learn the clipboard now has content,
+  // so its Paste stays disabled and pasting across files silently does nothing.
+  // A repaint (not just a state post) is needed because a lazy cut makes NO
+  // text edit, yet its source row must gain the dimmed affordance, and the
+  // owning document must repaint to show it (and to clear it after paste).
+  private static readonly liveWebviews = new Map<vscode.Webview, () => void>();
 
   private static broadcastClipboardState(): void {
-    for (const wv of SlddTextEditorProvider.liveWebviews) {
+    for (const [wv, repaint] of SlddTextEditorProvider.liveWebviews) {
       wv.postMessage({ type: 'clipboardState', ...clipboardState() });
+      // Repaint so the cut/copied source row shows (or clears) its affordance.
+      repaint();
+    }
+  }
+
+  // Broadcast the current drag descriptor (or null when a drag ends) to every
+  // live webview, mirroring the clipboard broadcast. Because HTML5 dataTransfer
+  // does not survive the webview iframe boundary, the dragged rows live in the
+  // host drag register; each webview learns of the in-flight drag through this
+  // descriptor and predicts the drop locally (dropDecision) on dragover.
+  private static broadcastDragState(): void {
+    const descriptor = dragDescriptor();
+    for (const wv of SlddTextEditorProvider.liveWebviews.keys()) {
+      wv.postMessage({ type: 'dragState', descriptor });
     }
   }
 
@@ -63,9 +84,6 @@ export class SlddTextEditorProvider implements vscode.CustomTextEditorProvider {
     const distRoot = vscode.Uri.joinPath(this.context.extensionUri, 'dist', 'webview');
     webview.options = { enableScripts: true, localResourceRoots: [distRoot] };
 
-    // Track this webview so clipboard-state changes from any editor reach it.
-    SlddTextEditorProvider.liveWebviews.add(webview);
-
     // Give the table tab a distinct table glyph instead of VS Code's default
     // JSON `{}` icon (which the plain-text view of the same .sldd also shows, so
     // the two tabs would otherwise be indistinguishable). Reuse the built-in
@@ -93,7 +111,15 @@ export class SlddTextEditorProvider implements vscode.CustomTextEditorProvider {
           initialized = true;
         }
         const modified = computeModified(uriString, node);
-        const rows = buildRows(node, modified);
+        // If the clipboard's cut/copied entry lives in THIS document, stamp its
+        // source row so the table can render the cut (dimmed) / copied (dashed)
+        // affordance. Cleared automatically once the clipboard empties on paste.
+        const clip = getClipboard();
+        const clipMark: ClipMark | undefined =
+          clip && clip.sourceDocUri === uriString && clip.payload.name
+            ? { name: clip.payload.name as string, section: clip.sourceSection, mode: clip.mode }
+            : undefined;
+        const rows = buildRows(node, modified, clipMark);
         // Fill the Usage column from the shared usage graph, then post. The graph
         // builds lazily on first use and is cached, so only the very first open in
         // a session pays the scan cost; subsequent posts resolve near-instantly.
@@ -107,6 +133,9 @@ export class SlddTextEditorProvider implements vscode.CustomTextEditorProvider {
               columnLabels: COLUMN_LABELS,
               editable: true,
             });
+            // Ship this document's section drop-rules so the webview can predict
+            // a drop (dropDecision) live on dragover without a host round-trip.
+            webview.postMessage({ type: 'sectionRules', docUri: uriString, rules: sectionRules(node) });
             webview.postMessage({ type: 'clipboardState', ...clipboardState() });
             // If a cross-tab navigation targeted this file (e.g. it was just
             // opened by a Usage-link click), select the requested row now.
@@ -122,6 +151,11 @@ export class SlddTextEditorProvider implements vscode.CustomTextEditorProvider {
       }
     };
 
+    // Track this webview (mapped to its repaint) so clipboard-state changes from
+    // any editor reach it — including a lazy cut, which only marks the clipboard
+    // and needs a repaint to show the source row's affordance.
+    SlddTextEditorProvider.liveWebviews.set(webview, post);
+
     // Apply new full text to the TextDocument via a WorkspaceEdit. This feeds
     // VS Code's native undo stack (so undo/redo + dirty are automatic) and fires
     // onDidChangeTextDocument, which repaints the table and any open text view.
@@ -236,8 +270,11 @@ export class SlddTextEditorProvider implements vscode.CustomTextEditorProvider {
         if (!entry) return false;
         const payload = entry.serialize() as Record<string, unknown>;
         const sectionName: string = entry.parent?.name ?? '';
-        setClipboard(payload, mode, sectionName);
-        // Broadcast so every open table (not just this one) enables Paste.
+        // Record which document this came from: a lazy cut defers the source
+        // delete to paste time, and the paste may land in another .sldd tab.
+        setClipboard(payload, mode, sectionName, uriString);
+        // Broadcast so every open table (not just this one) enables Paste and
+        // repaints — the cut/copied source row shows its affordance.
         SlddTextEditorProvider.broadcastClipboardState();
         return true;
       } catch {
@@ -284,15 +321,15 @@ export class SlddTextEditorProvider implements vscode.CustomTextEditorProvider {
     const applyAddChild = (msg: { rowId: string }): Promise<void> =>
       applyStructural(msg.rowId, (text, node) => addChildEdit(text, node));
 
-    // Cut = copy the node, then delete it. Native undo coalesces? No — two
-    // WorkspaceEdits would be two undo steps; here copy makes no text change, so
-    // cut is exactly one text edit (the delete) = one undo step.
-    const applyCut = async (msg: { rowId: string }): Promise<void> => {
+    // Cut is LAZY: it only marks the entry on the clipboard (in cut mode) and
+    // makes no text edit yet. The source is removed at PASTE time — so a
+    // same-document move becomes a single combined WorkspaceEdit (one undo step)
+    // and the cut source row can show its dimmed affordance until pasted. This
+    // mirrors data explorer's ClipboardService, whose cut() marks only.
+    const applyCut = (msg: { rowId: string }): void => {
       if (!applyCopy(msg, 'cut')) {
         webview.postMessage({ type: 'error', message: 'Could not cut the selected item.' });
-        return;
       }
-      await applyStructural(msg.rowId, deleteTransform);
     };
 
     // --- Location in Text (reveal the row's entry in the plain-text view) -------
@@ -345,25 +382,65 @@ export class SlddTextEditorProvider implements vscode.CustomTextEditorProvider {
     const applyPaste = async (msg: { rowId: string }): Promise<void> => {
       try {
         if (!ensureValidJson()) return;
-        const currentText = document.getText();
+        const clip = getClipboard();
+        if (!clip) {
+          webview.postMessage({ type: 'error', message: 'Nothing to paste — the clipboard is empty.' });
+          return;
+        }
 
+        // Resolve the target section first, so we can detect a same-section cut
+        // (a no-op the same-document drag path also refuses) before any edit.
+        let currentText = document.getText();
         invalidate(uriString);
-        const model = getModel(uriString, name, currentText);
-        const node = findNode(uriString, msg.rowId);
-        const section = resolveSectionForPaste(model, node, msg.rowId);
+        let model = getModel(uriString, name, currentText);
+        let node = findNode(uriString, msg.rowId);
+        let section = resolveSectionForPaste(model, node, msg.rowId);
         if (!section) {
           webview.postMessage({ type: 'error', message: 'Could not resolve the target section.' });
           return;
         }
-        const clip = getClipboard();
-        if (!clip) {
-          webview.postMessage({ type: 'error', message: 'Nothing to paste — the clipboard is empty.' });
+
+        const isCut = clip.mode === 'cut';
+        const sameDoc = clip.sourceDocUri === uriString;
+        const srcName = (clip.payload.name as string) || '';
+
+        // A cut pasted back into the very section it came from is a no-op:
+        // deleting then re-adding the same entry would just churn the document.
+        if (isCut && sameDoc && clip.sourceSection === section.name) {
+          clearClipboard();
+          SlddTextEditorProvider.broadcastClipboardState();
           return;
         }
+
+        // A same-document cut is a MOVE: remove the source first (in the same
+        // text) so the paste keeps the original name, then re-resolve against
+        // the trimmed model. This makes the whole move ONE WorkspaceEdit = one
+        // undo step (mirrors the same-document drag-move).
+        if (isCut && sameDoc && srcName) {
+          currentText = deleteEntriesByName(currentText, [srcName]);
+          invalidate(uriString);
+          model = getModel(uriString, name, currentText);
+          node = findNode(uriString, msg.rowId);
+          section = resolveSectionForPaste(model, node, msg.rowId);
+          if (!section) {
+            webview.postMessage({ type: 'error', message: 'Could not resolve the target section.' });
+            return;
+          }
+        }
+
         const { newText, selectId } = pasteEntry(currentText, section, clip.payload);
         await replaceAll(newText);
         if (selectId) webview.postMessage({ type: 'selectRow', rowId: selectId });
-        if (clip.mode === 'cut') {
+
+        // A cross-document cut removes the source from ITS document via that
+        // document's own WorkspaceEdit (a second, native undo step — exactly a
+        // cut in one file + paste in another).
+        if (isCut && !sameDoc && clip.sourceDocUri && srcName) {
+          await deleteFromSourceDocument(clip.sourceDocUri, [srcName]);
+        }
+
+        // The cut is now consumed; a copy stays on the clipboard for re-paste.
+        if (isCut) {
           clearClipboard();
           SlddTextEditorProvider.broadcastClipboardState();
         }
@@ -372,6 +449,132 @@ export class SlddTextEditorProvider implements vscode.CustomTextEditorProvider {
       }
     };
 
+    // --- Drag start: snapshot the dragged rows into the host drag register ------
+    // Mirrors applyCopy but for possibly-many rows: each row's owning entry is
+    // serialized (the payload the eventual paste uses) alongside the display
+    // facts (class/kind) the webview needs to predict the drop. Then broadcast
+    // the payload-free descriptor so every open table can render live feedback.
+    const applyDragStart = (msg: { rowIds: string[] }): void => {
+      try {
+        const currentText = document.getText();
+        invalidate(uriString);
+        getModel(uriString, name, currentText);
+        const rowIds = Array.isArray(msg.rowIds) ? msg.rowIds : [];
+        const items: DragRegisterItem[] = [];
+        let sourceSection = '';
+        let sourceSectionLabel = '';
+        let sourceIsDerived = false;
+        for (const rowId of rowIds) {
+          const node = findNode(uriString, rowId);
+          if (!node) continue;
+          const entry = findOwningEntry(node);
+          if (!entry || !entry.isEntry) continue;
+          const payload = entry.serialize() as Record<string, unknown>;
+          const value = payload.value as Record<string, unknown> | undefined;
+          const arrayClass = (value && typeof value === 'object' && (value._array_class as string)) || '';
+          items.push({
+            payload,
+            className: entry.className ?? '',
+            arrayClass,
+            kind: entry.kind ?? '',
+            isMatlabVariable: !arrayClass,
+          });
+          const section = entry.parent;
+          if (section) {
+            sourceSection = section.name ?? '';
+            sourceSectionLabel = section.displayName ?? section.name ?? '';
+            sourceIsDerived = !!entry.isDerived;
+          }
+        }
+        if (items.length === 0) {
+          clearDrag();
+        } else {
+          setDrag(uriString, sourceSection, sourceSectionLabel, sourceIsDerived, items);
+        }
+        SlddTextEditorProvider.broadcastDragState();
+      } catch {
+        clearDrag();
+        SlddTextEditorProvider.broadcastDragState();
+      }
+    };
+
+    // --- Drag end: clear the register and tell every webview the drag is over ---
+    const applyDragEnd = (): void => {
+      clearDrag();
+      SlddTextEditorProvider.broadcastDragState();
+    };
+
+    // --- Drop: complete the drag as copy/cut + paste ----------------------------
+    // A drop is exactly the cut/copy-paste it mirrors: paste the dragged payloads
+    // into the target section; for a MOVE, first remove the sources (so names are
+    // preserved, just as cut-then-paste does). Same-document moves delete + paste
+    // in one text; a cross-document move deletes from the source document via its
+    // own edit. The target section is resolved from the dropped-on row, which may
+    // be a section header (an empty section's only drop target).
+    const applyDrop = async (msg: { rowId: string; mode: 'copy' | 'move' }): Promise<void> => {
+      try {
+        if (!ensureValidJson()) return;
+        const drag = getDrag();
+        if (!drag || drag.items.length === 0) {
+          webview.postMessage({ type: 'error', message: 'Nothing to drop.' });
+          return;
+        }
+        const payloads = drag.items.map((it) => it.payload);
+        const isMove = msg.mode === 'move';
+        const sameDoc = drag.sourceDocUri === uriString;
+        const sourceNames = drag.items
+          .map((it) => (it.payload.name as string) || '')
+          .filter((n) => n.length > 0);
+
+        let currentText = document.getText();
+        // A same-document move removes the originals first so the pasted copies
+        // keep their names (mirrors cut-then-paste). A copy, or a cross-document
+        // move, leaves this document's originals untouched here.
+        if (isMove && sameDoc) {
+          currentText = deleteEntriesByName(currentText, sourceNames);
+        }
+
+        invalidate(uriString);
+        const model = getModel(uriString, name, currentText);
+        const node = findNode(uriString, msg.rowId);
+        const section = resolveSectionForPaste(model, node, msg.rowId);
+        if (!section) {
+          webview.postMessage({ type: 'error', message: 'Could not resolve the target section.' });
+          return;
+        }
+
+        const { newText, selectIds } = pasteEntries(currentText, section, payloads);
+        await replaceAll(newText);
+        if (selectIds.length) webview.postMessage({ type: 'selectRow', rowId: selectIds[selectIds.length - 1] });
+
+        // Cross-document move: remove the originals from the SOURCE document via
+        // its own WorkspaceEdit (a second native undo step, exactly like a
+        // cut in one file + paste in another).
+        if (isMove && !sameDoc) {
+          await deleteFromSourceDocument(drag.sourceDocUri, sourceNames);
+        }
+
+        clearDrag();
+        SlddTextEditorProvider.broadcastDragState();
+      } catch (err) {
+        webview.postMessage({ type: 'error', message: `Failed to apply edit: ${(err as Error).message}` });
+      }
+    };
+
+    // Remove named entries from a document that is NOT this webview's, for a
+    // cross-file move. Opens the target document (whether or not its table is
+    // open) and applies a full-text replace as one WorkspaceEdit.
+    const deleteFromSourceDocument = async (sourceUri: string, names: string[]): Promise<void> => {
+      const uri = vscode.Uri.parse(sourceUri);
+      const srcDoc = await vscode.workspace.openTextDocument(uri);
+      const srcText = srcDoc.getText();
+      const trimmed = deleteEntriesByName(srcText, names);
+      if (trimmed === srcText) return;
+      const edit = new vscode.WorkspaceEdit();
+      edit.replace(uri, new vscode.Range(srcDoc.positionAt(0), srcDoc.positionAt(srcText.length)), trimmed);
+      await vscode.workspace.applyEdit(edit);
+    };
+
     // --- Message wiring ---------------------------------------------------------
     const sub = webview.onDidReceiveMessage((msg) => {
       if (msg?.type === 'ready') {
@@ -387,9 +590,15 @@ export class SlddTextEditorProvider implements vscode.CustomTextEditorProvider {
       } else if (msg?.type === 'addChild') {
         void applyAddChild(msg);
       } else if (msg?.type === 'cut') {
-        void applyCut(msg);
+        applyCut(msg);
       } else if (msg?.type === 'paste') {
         void applyPaste(msg);
+      } else if (msg?.type === 'dragStart') {
+        applyDragStart(msg);
+      } else if (msg?.type === 'dragEnd') {
+        applyDragEnd();
+      } else if (msg?.type === 'drop') {
+        void applyDrop(msg);
       } else if (msg?.type === 'locateInText') {
         void applyLocateInText(msg);
       } else if (msg?.type === 'navigate') {
@@ -439,6 +648,12 @@ export class SlddTextEditorProvider implements vscode.CustomTextEditorProvider {
     webview.html = this.getHtml(webview, distRoot);
     webviewPanel.onDidDispose(() => {
       SlddTextEditorProvider.liveWebviews.delete(webview);
+      // If a drag originated from this now-closing view, drop it so a stale
+      // register can't complete against another document.
+      if (getDrag()?.sourceDocUri === uriString) {
+        clearDrag();
+        SlddTextEditorProvider.broadcastDragState();
+      }
       sub.dispose();
       changeSub.dispose();
       saveSub.dispose();
diff --git a/src/host/clipboard.ts b/src/host/clipboard.ts
index 6cd7699..4680928 100644
--- a/src/host/clipboard.ts
+++ b/src/host/clipboard.ts
@@ -11,12 +11,21 @@ interface ClipboardEntry {
   payload: Record<string, unknown>;
   mode: ClipboardMode;
   sourceSection: string;
+  // The document the entry was cut/copied from. A lazy cut defers the source
+  // delete until paste, so it must remember WHICH document to delete from —
+  // the paste may land in a different .sldd tab (a cross-document move).
+  sourceDocUri?: string;
 }
 
 let current: ClipboardEntry | null = null;
 
-export function setClipboard(payload: Record<string, unknown>, mode: ClipboardMode, sourceSection: string): void {
-  current = { payload, mode, sourceSection };
+export function setClipboard(
+  payload: Record<string, unknown>,
+  mode: ClipboardMode,
+  sourceSection: string,
+  sourceDocUri?: string,
+): void {
+  current = { payload, mode, sourceSection, sourceDocUri };
 }
 
 export function getClipboard(): ClipboardEntry | null {
diff --git a/src/host/dragState.ts b/src/host/dragState.ts
new file mode 100644
index 0000000..40c16ed
--- /dev/null
+++ b/src/host/dragState.ts
@@ -0,0 +1,76 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// The drag register: a single module-level record of the rows currently being
+// dragged, mirroring the clipboard singleton (clipboard.ts). It exists because
+// HTML5 dataTransfer does not reliably survive the webview iframe boundary — so
+// on drag start the host snapshots the dragged entries here, and on drop the
+// target webview asks the host to complete the drop, which reads the payloads
+// back from this register. Between the two, the host broadcasts a lightweight
+// DESCRIPTOR (source metadata + per-item class/kind, NOT the payloads) to every
+// webview so each can predict the drop live (dropDecision) on dragover.
+
+// One dragged entry: its serialized payload (for the eventual paste) plus the
+// display facts the webview needs to render feedback without a model.
+export interface DragRegisterItem {
+  payload: Record<string, unknown>;
+  className: string;
+  arrayClass: string;
+  kind: string;
+  isMatlabVariable: boolean;
+}
+
+interface DragEntry {
+  sourceDocUri: string;
+  sourceSection: string;
+  sourceSectionLabel: string;
+  sourceIsDerived: boolean;
+  items: DragRegisterItem[];
+}
+
+// The lightweight descriptor broadcast to webviews. It mirrors dropDecision's
+// DragSource shape and deliberately OMITS the payloads (they can be large and
+// the webview never needs them — the drop is completed host-side).
+export interface DragDescriptor {
+  docUri: string;
+  sectionName: string;
+  sectionLabel: string;
+  isDerived: boolean;
+  items: Array<{ className: string; arrayClass: string; kind: string; isMatlabVariable: boolean }>;
+}
+
+let current: DragEntry | null = null;
+
+export function setDrag(
+  sourceDocUri: string,
+  sourceSection: string,
+  sourceSectionLabel: string,
+  sourceIsDerived: boolean,
+  items: DragRegisterItem[],
+): void {
+  current = { sourceDocUri, sourceSection, sourceSectionLabel, sourceIsDerived, items };
+}
+
+export function getDrag(): DragEntry | null {
+  return current;
+}
+
+export function clearDrag(): void {
+  current = null;
+}
+
+/** The payload-free descriptor posted to every webview for live drag feedback. */
+export function dragDescriptor(): DragDescriptor | null {
+  if (!current) return null;
+  return {
+    docUri: current.sourceDocUri,
+    sectionName: current.sourceSection,
+    sectionLabel: current.sourceSectionLabel,
+    isDerived: current.sourceIsDerived,
+    items: current.items.map((it) => ({
+      className: it.className,
+      arrayClass: it.arrayClass,
+      kind: it.kind,
+      isMatlabVariable: it.isMatlabVariable,
+    })),
+  };
+}
diff --git a/src/host/rowBuilder.ts b/src/host/rowBuilder.ts
index 986b55f..3a58109 100644
--- a/src/host/rowBuilder.ts
+++ b/src/host/rowBuilder.ts
@@ -16,11 +16,23 @@ export const PROJECT_COLUMN_LABELS: Record<string, string> = {
   Name: 'Name', Type: 'Type', Location: 'Location', Labels: 'Labels',
 };
 
-export function buildRows(sldd: any, modifiedNames?: Set<string>): any[] {
+// Identifies the single entry currently marked on the host clipboard, so its
+// source row can render the cut (dimmed) / copied (dashed) affordance. Matched
+// by name AND section because entry names are only unique within a section.
+export interface ClipMark {
+  name: string;
+  section: string;
+  mode: 'cut' | 'copy';
+}
+
+export function buildRows(sldd: any, modifiedNames?: Set<string>, clipMark?: ClipMark): any[] {
   const rows: any[] = [];
   const sections = (sldd.children || []) as any[];
   for (const section of sections) {
     const entries = (section.children || []) as any[];
+    // Only the section the clipboard entry lives in can carry the mark, so pass
+    // the mode down solely for that section (name uniqueness is per-section).
+    const sectionMark = clipMark && clipMark.section === section.name ? clipMark : undefined;
     // Always emit the section row, even when it has no entries.
     // Parent row for the section
     rows.push({
@@ -31,7 +43,7 @@ export function buildRows(sldd: any, modifiedNames?: Set<string>): any[] {
     });
     // Entry rows (flatten each entry subtree so nested struct/bus children appear)
     for (const entry of entries) {
-      rows.push(...buildEntryRows(entry, section.name, modifiedNames));
+      rows.push(...buildEntryRows(entry, section.name, modifiedNames, sectionMark));
     }
   }
   return rows;
@@ -62,7 +74,7 @@ function capabilityFlags(n: any): {
 // nested children), reparented under its section. Used both by buildRows for
 // the full tree and by the incremental edit write-back, which repaints only
 // the edited entry's rows instead of rebuilding the whole table.
-export function buildEntryRows(entry: any, sectionName: string, modifiedNames?: Set<string>): any[] {
+export function buildEntryRows(entry: any, sectionName: string, modifiedNames?: Set<string>, clipMark?: ClipMark): any[] {
   const out: any[] = [];
   const flat = entry.flatten ? entry.flatten() : [entry];
   for (const n of flat) {
@@ -86,6 +98,12 @@ export function buildEntryRows(entry: any, sectionName: string, modifiedNames?:
     if (row.ID === entry.id && modifiedNames?.has(entry.name)) {
       row = { ...row, Status: 'Modified' };
     }
+    // Stamp the clipboard affordance on the cut/copied entry's own row (the
+    // section is pre-matched by the caller, so here just match the name). The
+    // table reads Name.clipboardMode to dim (cut) or dash-outline (copied).
+    if (row.ID === entry.id && clipMark && clipMark.name === entry.name && row.Name && typeof row.Name === 'object') {
+      row = { ...row, Name: { ...row.Name, clipboardMode: clipMark.mode } };
+    }
     // Context-menu capability flags (consumed by the webview menu builder).
     out.push({ ...row, ...capabilityFlags(n) });
   }
diff --git a/src/host/sectionRules.ts b/src/host/sectionRules.ts
new file mode 100644
index 0000000..13a3e5c
--- /dev/null
+++ b/src/host/sectionRules.ts
@@ -0,0 +1,27 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// sectionRules distills, from a live model, the per-section facts the webview
+// needs to PREDICT a drop locally (dropDecision) without a host round-trip on
+// every dragover: the section name, its human label, whether it is derived
+// (architectural), and the classes it accepts. It is posted to each webview
+// alongside its rows, and mirrors SectionNode's allow-list + the section→
+// isderived mapping so the webview's prediction matches what the host paste
+// would actually do.
+import { getSectionMetadata } from '../dex/datamodel/SectionConstants.js';
+
+export interface SectionRule {
+  sectionName: string;
+  sectionLabel: string;
+  isDerived: boolean;
+  allowedTypes: string[];
+}
+
+export function sectionRules(model: any): SectionRule[] {
+  const sections = (model?.children ?? []) as any[];
+  return sections.map((s) => ({
+    sectionName: s.name,
+    sectionLabel: s.displayName ?? s.name,
+    isDerived: getSectionMetadata(s.name).isderived === '1',
+    allowedTypes: typeof s.getAllowedTypes === 'function' ? s.getAllowedTypes() : [],
+  }));
+}
diff --git a/src/host/structuralEdit.ts b/src/host/structuralEdit.ts
index ad373c4..a92bcf4 100644
--- a/src/host/structuralEdit.ts
+++ b/src/host/structuralEdit.ts
@@ -189,3 +189,61 @@ export function pasteEntry(
   const newText = text.slice(0, insertion.offset) + inserted + text.slice(insertion.offset);
   return { newText, selectId: newNode.id };
 }
+
+/**
+ * Source-side of a MOVE drop: remove the dragged entries from the SOURCE text by
+ * name. Works purely on text so it applies to any document (the move source may
+ * differ from the paste target). Each named top-level entry's array element is
+ * spliced out; spans are removed high-offset-first so earlier removals don't
+ * shift the offsets of later ones. Names not present are silently skipped, so an
+ * already-absent entry never throws (and an all-absent list returns the text
+ * unchanged, byte-identical).
+ */
+export function deleteEntriesByName(text: string, names: string[]): string {
+  const spans: { offset: number; length: number }[] = [];
+  for (const name of names) {
+    const span = findEntryElementSpan(text, name);
+    if (span) spans.push(span);
+  }
+  // Remove from the end so each splice leaves earlier offsets valid.
+  spans.sort((a, b) => b.offset - a.offset);
+  let out = text;
+  for (const span of spans) {
+    out = out.slice(0, span.offset) + out.slice(span.offset + span.length);
+  }
+  return out;
+}
+
+/**
+ * Drop-completion transform: paste MANY payloads into `section` in one edit —
+ * exactly what a multi-select drop needs. It is a fold over pasteEntry: each
+ * paste re-inserts into the text produced by the previous one AND adds the new
+ * node to the live `section`, so `_uniqueName` sees the growing namespace and
+ * every dropped entry gets a distinct name (a first Bus becomes Bus1, a second
+ * Bus2). The allow-check is all-or-nothing: any disallowed payload throws before
+ * any text changes, so a rejected multi-drop leaves the document untouched. A
+ * move deletes the sources separately (the host, via deleteEntry) — this side
+ * is purely the paste, identical to how drop mirrors copy/cut + paste.
+ */
+export function pasteEntries(
+  text: string,
+  section: any,
+  payloads: Record<string, unknown>[],
+): { newText: string; selectIds: string[] } {
+  // All-or-nothing allow-check up front: reject the whole drop before mutating
+  // any text or the section, so a bad item can't leave a half-applied paste.
+  for (const payload of payloads) {
+    const className = payloadClassName(payload);
+    if (className && typeof section.allowsType === 'function' && !section.allowsType(className)) {
+      throw new Error(`A "${className}" entry is not allowed in ${section.displayName ?? section.name}.`);
+    }
+  }
+  let currentText = text;
+  const selectIds: string[] = [];
+  for (const payload of payloads) {
+    const { newText, selectId } = pasteEntry(currentText, section, payload);
+    currentText = newText;
+    if (selectId) selectIds.push(selectId);
+  }
+  return { newText: currentText, selectIds };
+}
diff --git a/src/webview/dragMode.ts b/src/webview/dragMode.ts
new file mode 100644
index 0000000..f07ac48
--- /dev/null
+++ b/src/webview/dragMode.ts
@@ -0,0 +1,27 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// The copy-vs-move modifier for a drag follows the PLATFORM convention, because
+// the browser derives the native dropEffect from the OS modifier: requesting an
+// effect the OS modifier doesn't grant makes the browser force dropEffect='none'
+// and cancel the drop before it fires. So we must read the SAME key the OS uses:
+//   • macOS: a plain drag moves; Option (Alt) requests a copy. Cmd means move
+//     (the Finder convention), so it is NOT the copy key.
+//   • Windows / Linux: a plain drag moves; Ctrl requests a copy.
+// Kept pure (a platform string in, a mode out) so the convention is unit-tested
+// on every platform, including ones we can't launch interactively.
+
+export type DragMode = 'copy' | 'move';
+
+/** True for macOS/iOS platform strings (navigator.platform or userAgentData). */
+export function isMacPlatform(platform: string): boolean {
+  return /mac|iphone|ipad/i.test(platform);
+}
+
+/** The drag mode for the given platform and the modifier keys currently held. */
+export function dragModeFromModifiers(
+  platform: string,
+  mods: { altKey: boolean; ctrlKey: boolean },
+): DragMode {
+  const wantsCopy = isMacPlatform(platform) ? mods.altKey : mods.ctrlKey;
+  return wantsCopy ? 'copy' : 'move';
+}
diff --git a/src/webview/dropDecision.ts b/src/webview/dropDecision.ts
new file mode 100644
index 0000000..7db3043
--- /dev/null
+++ b/src/webview/dropDecision.ts
@@ -0,0 +1,119 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// dropDecision is the PURE predictor behind drag-and-drop feedback: given the
+// dragged rows (source) and the section under the cursor (target), it returns
+// whether a drop is allowed, which cursor to show, and the hover tooltip.
+//
+// It exists so the webview can render live drag feedback WITHOUT a round-trip to
+// the host on every dragover. It must mirror the host exactly:
+//   • accept/reject mirrors pasteEntry's allow-check — a payload's array-class
+//     must be in the target section's allowed types (an empty array-class, i.e.
+//     a plain MATLAB variable, is never rejected, just like pasteEntry).
+//   • the tooltip's Kind labels mirror the Kind an entry shows AFTER the paste:
+//     a pasted entry loses its SystemComposer classification (its new name isn't
+//     in the catalog), so its Kind comes from class + the target's derived flag.
+//     kindForClass with NO classification reproduces that post-paste Kind.
+//
+// The bottom line it enforces: drag-drop matches cut/copy-paste — if you can
+// cut/copy you can drag, and if you can paste you can drop.
+import { kindForClass } from '../dex/datamodel/kindMap.js';
+
+export type DragMode = 'copy' | 'move';
+export type DropCursor = 'copy' | 'move' | 'no-drop';
+
+// One dragged row, as the webview knows it (no live model). `arrayClass` is the
+// serialized entry's _array_class ('' for a MATLAB variable); `className` is the
+// raw class shown in the Class column; `kind` is the Kind currently displayed.
+export interface DragItem {
+  className: string;
+  arrayClass: string;
+  kind: string;
+  isMatlabVariable: boolean;
+}
+
+export interface DragSource {
+  docUri: string;
+  sectionName: string;
+  sectionLabel: string;
+  isDerived: boolean;
+  items: DragItem[];
+}
+
+export interface DropTarget {
+  docUri: string;
+  sectionName: string;
+  sectionLabel: string;
+  isDerived: boolean;
+  allowedTypes: string[];
+}
+
+export interface DropDecision {
+  canDrop: boolean;
+  cursor: DropCursor;
+  tooltip: string;
+  noop: boolean;
+}
+
+// Mirror SectionNode.allowsType: an empty array-class (MATLAB variable) is
+// always accepted; otherwise the class must be in the allow-list. An empty
+// allow-list means "no restriction".
+function targetAllows(target: DropTarget, item: DragItem): boolean {
+  if (!item.arrayClass) return true;
+  if (target.allowedTypes.length === 0) return true;
+  return target.allowedTypes.indexOf(item.arrayClass) !== -1;
+}
+
+// The Kind an item WILL show once dropped into `target`: class + the target's
+// derived flag, with NO classification (a pasted entry's new name isn't in the
+// SystemComposer catalog, so it never keeps a classification-derived Kind).
+function kindInTarget(item: DragItem, target: DropTarget): string {
+  return kindForClass(item.className, {
+    isDerived: target.isDerived,
+    isMatlabVariable: item.isMatlabVariable,
+  });
+}
+
+function reject(tooltip: string): DropDecision {
+  return { canDrop: false, cursor: 'no-drop', tooltip, noop: false };
+}
+
+export function dropDecision(source: DragSource, target: DropTarget, mode: DragMode): DropDecision {
+  const items = source.items ?? [];
+  if (items.length === 0) return reject('Nothing to drop');
+
+  // Same document + same section + move = reorder within one section, which we
+  // treat as a no-op (a move here would delete and re-add the same entry). A
+  // COPY into the same section is a genuine duplicate, so it is allowed.
+  const sameSection = source.docUri === target.docUri && source.sectionName === target.sectionName;
+  if (sameSection && mode === 'move') {
+    return { canDrop: false, cursor: 'no-drop', tooltip: '', noop: true };
+  }
+
+  // Any single rejected item rejects the whole drop (mirrors a multi-select
+  // paste, which is all-or-nothing).
+  const rejected = items.find((it) => !targetAllows(target, it));
+  if (rejected) {
+    return reject(`${rejected.kind} cannot be in ${target.sectionLabel}`);
+  }
+
+  const cursor: DropCursor = mode === 'copy' ? 'copy' : 'move';
+  return { canDrop: true, cursor, tooltip: dropTooltip(items, target, mode), noop: false };
+}
+
+// The hover label for an allowed drop. The verb reflects the LIVE drag mode —
+// "Copy" while Ctrl/Cmd is held, "Move" otherwise — so it matches the action the
+// drop will actually perform. Single item: name the Kind and, when the drop
+// changes it (design↔arch), phrase it as a conversion. Multiple items: a count
+// label, still distinguishing a same-Kind move/copy from a conversion.
+function dropTooltip(items: DragItem[], target: DropTarget, mode: DragMode): string {
+  const verb = mode === 'copy' ? 'Copy' : 'Move';
+  if (items.length === 1) {
+    const it = items[0];
+    const from = it.kind;
+    const to = kindInTarget(it, target);
+    return from === to ? `${verb} ${from}` : `Convert ${from} to ${to}`;
+  }
+  const converts = items.some((it) => it.kind !== kindInTarget(it, target));
+  if (converts) return `Convert ${items.length} items to ${target.sectionLabel}`;
+  return `${verb} ${items.length} items`;
+}
diff --git a/src/webview/table-main.ts b/src/webview/table-main.ts
index 8dd9175..606fab1 100644
--- a/src/webview/table-main.ts
+++ b/src/webview/table-main.ts
@@ -6,6 +6,9 @@ import '../dex/components/dex-context-menu.js';
 import '../dex/components/dex-error-dialog.js';
 import { nextExpandedIds } from './rowUpdates.js';
 import { buildContextMenuItems, shouldShowContextMenu, shouldOpenCellEditor, resolveShortcutAction, type ClipboardState, type MenuRow } from './menuItems.js';
+import { dropDecision, type DragMode, type DropTarget, type DragSource } from './dropDecision.js';
+import type { SectionRule } from '../host/sectionRules.js';
+import type { DragDescriptor } from '../host/dragState.js';
 
 declare function acquireVsCodeApi(): { postMessage(msg: unknown): void };
 const vscode = acquireVsCodeApi();
@@ -21,6 +24,62 @@ let clipboardState: ClipboardState = { canPaste: false, mode: null };
 // The row id under the last right-click, relayed with the chosen action.
 let lastContextRowId: string | null = null;
 
+// This document's uri + its section drop-rules, shipped by the host with each
+// setRows. Together with the broadcast drag descriptor they let the predictor
+// run dropDecision entirely client-side on dragover (no host round-trip).
+let docUri = '';
+let sectionRulesList: SectionRule[] = [];
+// The in-flight drag broadcast from the host (null when no drag is active).
+// Because a drag can originate in another webview, this — not local
+// dataTransfer — is the authoritative source of what is being dragged.
+let dragDescriptor: DragDescriptor | null = null;
+
+// Resolve the section a row belongs to: a section header (`section:<name>`) is
+// that section; a data row carries its section via its `parent` (also a header
+// id). Returns the matching SectionRule, or null if it can't be resolved.
+function sectionRuleForRow(rowId: string): SectionRule | null {
+  let sectionName: string | null = null;
+  if (rowId.indexOf('section:') === 0) {
+    sectionName = rowId.slice('section:'.length);
+  } else {
+    const row = (table.rows ?? []).find((r: { ID: string; parent?: string | null }) => r.ID === rowId);
+    const parent = row?.parent;
+    if (typeof parent === 'string' && parent.indexOf('section:') === 0) {
+      sectionName = parent.slice('section:'.length);
+    }
+  }
+  if (sectionName == null) return null;
+  return sectionRulesList.find((r) => r.sectionName === sectionName) ?? null;
+}
+
+// The predictor injected into the table: given the row under the cursor and the
+// drag mode, run the pure dropDecision against the broadcast drag descriptor and
+// this document's section rules. Returns null when there's no active drag or the
+// target section can't be resolved, so the table falls back to default behavior.
+function predictDrop(
+  targetRowId: string,
+  mode: DragMode,
+): { canDrop: boolean; cursor: string; tooltip: string; noop: boolean } | null {
+  if (!dragDescriptor) return null;
+  const rule = sectionRuleForRow(targetRowId);
+  if (!rule) return null;
+  const source: DragSource = {
+    docUri: dragDescriptor.docUri,
+    sectionName: dragDescriptor.sectionName,
+    sectionLabel: dragDescriptor.sectionLabel,
+    isDerived: dragDescriptor.isDerived,
+    items: dragDescriptor.items,
+  };
+  const target: DropTarget = {
+    docUri,
+    sectionName: rule.sectionName,
+    sectionLabel: rule.sectionLabel,
+    isDerived: rule.isDerived,
+    allowedTypes: rule.allowedTypes,
+  };
+  return dropDecision(source, target, mode);
+}
+
 // A row id the host asked us to select once it exists in the table. Set on a
 // rename (the row's id changes, so the old selection is stale); applied as soon
 // as a matching row is present, otherwise held until the rebuilt rows arrive.
@@ -138,6 +197,13 @@ window.addEventListener('message', (event: MessageEvent) => {
     applyPendingSelection();
   } else if (msg.type === 'clipboardState') {
     clipboardState = { canPaste: !!msg.canPaste, mode: msg.mode ?? null };
+  } else if (msg.type === 'sectionRules') {
+    docUri = typeof msg.docUri === 'string' ? msg.docUri : docUri;
+    sectionRulesList = Array.isArray(msg.rules) ? msg.rules : [];
+  } else if (msg.type === 'dragState') {
+    // The host broadcasts the in-flight drag (or null when it ends) to every
+    // webview, so a drag started in another tab predicts correctly here.
+    dragDescriptor = msg.descriptor ?? null;
   } else if (msg.type === 'error') {
     hideLoading();
     showError(msg.message);
@@ -272,6 +338,28 @@ contextMenu.addEventListener('dex-action', (e: Event) => {
   vscode.postMessage({ type: actionId, rowId: lastContextRowId });
 });
 
+// Inject the drop predictor so the table can render live cursor + tooltip
+// feedback on dragover (backed by the pure dropDecision + host-shipped rules).
+table.dropPredictor = predictDrop;
+
+// Drag lifecycle → host. On drag start the host snapshots the dragged rows into
+// its drag register and broadcasts the descriptor; on end it clears + rebroad-
+// casts; on drop it completes the move/copy as paste (+ source delete). All
+// gated on editable so read-only views never initiate a structural drag.
+table.addEventListener('dex-row-drag-start', (e: Event) => {
+  if (!editable) return;
+  const rowIds = (e as CustomEvent).detail?.rowIds ?? [];
+  vscode.postMessage({ type: 'dragStart', rowIds });
+});
+table.addEventListener('dex-row-drag-end', () => {
+  vscode.postMessage({ type: 'dragEnd' });
+});
+table.addEventListener('dex-row-drop', (e: Event) => {
+  if (!editable) return;
+  const detail = (e as CustomEvent).detail;
+  vscode.postMessage({ type: 'drop', rowId: detail.targetRowId, mode: detail.mode });
+});
+
 // Relay row selection to the host (for PI + tree sync in later phases).
 table.addEventListener('dex-row-selected', (e: Event) => {
   const detail = (e as CustomEvent).detail;
diff --git a/test-integration/suite/cutPasteUndo.test.ts b/test-integration/suite/cutPasteUndo.test.ts
new file mode 100644
index 0000000..d94c58c
--- /dev/null
+++ b/test-integration/suite/cutPasteUndo.test.ts
@@ -0,0 +1,150 @@
+// Copyright 2026 The MathWorks, Inc.
+// Integration guard for the LAZY-CUT move contract in real VS Code.
+//
+// Table cut is lazy: the cut makes no text edit; the whole move happens at
+// PASTE time as a SINGLE full-text WorkspaceEdit (SlddTextEditorProvider's
+// replaceAll — delete the source and add it to the target in one edit). The
+// payoff is undo granularity: a same-document move is ONE native undo step, not
+// the two steps the old eager cut+paste produced. That granularity lives in
+// VS Code's real undo stack, which the headless vitest suite cannot exercise —
+// so we assert it here.
+//
+// We cannot postMessage into the webview from the test host, and src/host does
+// not require() cleanly inside the Electron host (jsonc-parser), so — exactly as
+// liveEdit.test.ts does — we SIMULATE the provider's write-back: apply the
+// move's resulting full text as one WorkspaceEdit on the shared TextDocument,
+// then assert a single undo restores the original document byte-for-byte. The
+// move's byte-level correctness (uniquify/reparent/splice) is covered by the
+// vitest suites (structuralEdit, cutPasteEndToEnd); THIS test pins the one-edit,
+// one-undo contract against a live editor.
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+
+const TABLE_VIEW = 'dataExplorer.tableView';
+
+function slddUri(): vscode.Uri {
+  const ws = vscode.workspace.workspaceFolders?.[0];
+  assert.ok(ws, 'a workspace folder must be open');
+  return vscode.Uri.joinPath(ws.uri, 'data.sldd');
+}
+
+// Produce the text a same-document MOVE of one entry yields: remove the named
+// entry from the entries array and re-append it. This mirrors the NET effect of
+// the provider's deleteEntriesByName + pasteEntry (which the provider then
+// writes as a single full-text replace). We round-trip through JSON so the
+// result is guaranteed valid; the exact byte formatting is not what this test
+// asserts (unit tests cover the real byte-splice) — only that it is ONE edit
+// undone in ONE step.
+function moveEntryToEnd(text: string, name: string): string {
+  const doc = JSON.parse(text);
+  const parts = doc.__MW_TEXT_PARTS__;
+  const partKey = Object.keys(parts)[0];
+  const content = parts[partKey].__MW_TEXT_content;
+  const entries = content.entries as Array<{ name: string }>;
+  const idx = entries.findIndex((e) => e.name === name);
+  assert.ok(idx >= 0, `entry "${name}" exists in the fixture`);
+  const [moved] = entries.splice(idx, 1);
+  entries.push(moved);
+  return JSON.stringify(doc, null, 2);
+}
+
+suite('Data Explorer .sldd lazy-cut move — one edit, one undo', () => {
+  suiteSetup(async () => {
+    await vscode.extensions.getExtension('mathworks.simulink-data-explorer')?.activate();
+  });
+
+  teardown(async () => {
+    // Revert any unsaved edits so the fixture is untouched for the next test/run.
+    await vscode.commands.executeCommand('workbench.action.revertAndCloseActiveEditor');
+    await vscode.commands.executeCommand('workbench.action.closeAllEditors');
+  });
+
+  test('a same-document move applies as ONE WorkspaceEdit and a single undo restores the original', async () => {
+    const uri = slddUri();
+
+    // The one-edit/one-undo contract is a property of the shared TextDocument's
+    // native undo stack, which the provider's move write-back (replaceAll) feeds.
+    // Drive it through the text editor directly: the `undo` command routes to the
+    // ACTIVE editor, so we open ONLY the text editor and keep it active (opening
+    // the table view too would leave undo's target ambiguous across groups).
+    const doc = await vscode.workspace.openTextDocument(uri);
+    const editor = await vscode.window.showTextDocument(doc, { viewColumn: vscode.ViewColumn.One, preview: false });
+
+    const originalText = doc.getText();
+    assert.strictEqual(doc.isDirty, false, 'the document starts clean');
+
+    // Simulate the provider's move write-back: ONE full-range replace. The
+    // provider does this via a WorkspaceEdit (replaceAll); here we apply the SAME
+    // single full-range replace through editor.edit instead, because a
+    // WorkspaceEdit-driven undo does not route to the editor's undo stack in the
+    // headless Electron test host (undo becomes a no-op). Both are a single edit
+    // = a single undo stop — the granularity this test asserts is identical; only
+    // the apply mechanism differs so undo is observable in the test host.
+    const movedText = moveEntryToEnd(originalText, 'Number');
+    assert.notStrictEqual(movedText, originalText, 'the move changes the document text');
+
+    const fullRange = new vscode.Range(doc.positionAt(0), doc.positionAt(originalText.length));
+    const applied = await editor.edit((eb) => eb.replace(fullRange, movedText));
+    assert.strictEqual(applied, true, 'the move edit applied');
+    assert.ok(doc.isDirty, 'the document is dirty after the move');
+    assert.notStrictEqual(doc.getText(), originalText, 'the document reflects the move');
+    JSON.parse(doc.getText()); // the moved text is still valid JSON
+
+    // Undo through the editor's own command so it targets THIS editor's undo
+    // stack (not whatever the workbench considers globally active). A SINGLE undo
+    // must restore the ORIGINAL byte-for-byte: if the move were two edits (the old
+    // eager cut+paste), one undo would leave a partial, dirty state — the
+    // regression this test guards against.
+    assert.strictEqual(
+      vscode.window.activeTextEditor?.document.uri.toString(),
+      uri.toString(),
+      'the .sldd text editor is active so undo targets its stack',
+    );
+    await vscode.commands.executeCommand('default:undo');
+    await new Promise((r) => setTimeout(r, 300));
+
+    assert.strictEqual(doc.getText(), originalText, 'one undo restored the original text exactly');
+    assert.strictEqual(doc.isDirty, false, 'and the document is clean again (a full single-step undo)');
+    // Keep a reference to the editor so it is unmistakably the target of undo.
+    assert.ok(editor.document === doc, 'the editor renders the shared document');
+    assert.ok(
+      vscode.extensions.getExtension('mathworks.simulink-data-explorer')?.isActive,
+      'extension remains active through the move + undo',
+    );
+  });
+
+  test('cross-document source delete applies as its own WorkspaceEdit (separate undo step)', async () => {
+    // A cross-document cut pastes into the target, then deletes from the SOURCE
+    // document via that document's own WorkspaceEdit (SlddTextEditorProvider's
+    // deleteFromSourceDocument). There is a single editable .sldd fixture, so we
+    // model just the source side: opening the source document and applying a
+    // full-text delete-write is a distinct, revertible edit on THAT document —
+    // proving the cross-doc source edit is independent of any target edit.
+    const uri = slddUri();
+    const doc = await vscode.workspace.openTextDocument(uri);
+    await vscode.window.showTextDocument(doc, vscode.ViewColumn.Beside);
+
+    const originalText = doc.getText();
+    // Remove one entry (the source-delete half of a cross-document move).
+    const parsed = JSON.parse(originalText);
+    const partKey = Object.keys(parsed.__MW_TEXT_PARTS__)[0];
+    const entries = parsed.__MW_TEXT_PARTS__[partKey].__MW_TEXT_content.entries as Array<{ name: string }>;
+    const before = entries.length;
+    const trimmed = { ...parsed };
+    trimmed.__MW_TEXT_PARTS__[partKey].__MW_TEXT_content.entries = entries.filter((e) => e.name !== 'Number');
+    const trimmedText = JSON.stringify(trimmed, null, 2);
+
+    const edit = new vscode.WorkspaceEdit();
+    edit.replace(uri, new vscode.Range(doc.positionAt(0), doc.positionAt(originalText.length)), trimmedText);
+    const applied = await vscode.workspace.applyEdit(edit);
+    assert.strictEqual(applied, true, 'the source-delete edit applied');
+
+    const after = (JSON.parse(doc.getText()).__MW_TEXT_PARTS__[partKey].__MW_TEXT_content.entries as unknown[]).length;
+    assert.strictEqual(after, before - 1, 'exactly one entry was removed from the source document');
+    assert.ok(doc.isDirty, 'the source document is dirty (its own revertible edit)');
+    assert.ok(
+      vscode.extensions.getExtension('mathworks.simulink-data-explorer')?.isActive,
+      'extension remains active through the cross-document source delete',
+    );
+  });
+});
diff --git a/test/clipboard.test.ts b/test/clipboard.test.ts
index b3e2385..3919d5a 100644
--- a/test/clipboard.test.ts
+++ b/test/clipboard.test.ts
@@ -22,24 +22,39 @@ describe('clipboard', () => {
     expect(clipboardState()).toEqual({ canPaste: false, mode: null });
   });
 
-  it('stores a copied payload with its mode and source section', () => {
+  it('stores a copied payload with its mode, source section, and source document', () => {
     const payload = { name: 'Kp', value: 1 };
-    setClipboard(payload, 'copy', 'Design Data');
-    expect(getClipboard()).toEqual({ payload, mode: 'copy', sourceSection: 'Design Data' });
+    setClipboard(payload, 'copy', 'Design Data', 'file:///a.sldd');
+    expect(getClipboard()).toEqual({
+      payload,
+      mode: 'copy',
+      sourceSection: 'Design Data',
+      sourceDocUri: 'file:///a.sldd',
+    });
     expect(canPaste()).toBe(true);
     expect(clipboardState()).toEqual({ canPaste: true, mode: 'copy' });
   });
 
   it('records cut mode distinctly from copy', () => {
-    setClipboard({ name: 'X' }, 'cut', 'Design Data');
+    setClipboard({ name: 'X' }, 'cut', 'Design Data', 'file:///a.sldd');
     expect(getClipboard()?.mode).toBe('cut');
     expect(clipboardState()).toEqual({ canPaste: true, mode: 'cut' });
   });
 
+  it('remembers which document a cut came from (for the lazy source delete on paste)', () => {
+    setClipboard({ name: 'X' }, 'cut', 'Design Data', 'file:///source.sldd');
+    expect(getClipboard()?.sourceDocUri).toBe('file:///source.sldd');
+  });
+
   it('overwrites the previous entry on a second set', () => {
-    setClipboard({ name: 'first' }, 'copy', 'A');
-    setClipboard({ name: 'second' }, 'cut', 'B');
-    expect(getClipboard()).toEqual({ payload: { name: 'second' }, mode: 'cut', sourceSection: 'B' });
+    setClipboard({ name: 'first' }, 'copy', 'A', 'file:///a.sldd');
+    setClipboard({ name: 'second' }, 'cut', 'B', 'file:///b.sldd');
+    expect(getClipboard()).toEqual({
+      payload: { name: 'second' },
+      mode: 'cut',
+      sourceSection: 'B',
+      sourceDocUri: 'file:///b.sldd',
+    });
   });
 
   it('clears back to the empty state', () => {
diff --git a/test/cutPasteEndToEnd.test.ts b/test/cutPasteEndToEnd.test.ts
new file mode 100644
index 0000000..f557e5d
--- /dev/null
+++ b/test/cutPasteEndToEnd.test.ts
@@ -0,0 +1,155 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// End-to-end cut/copy/paste flows, modeling exactly what
+// SlddTextEditorProvider.applyPaste does with the pure transforms. Cut is LAZY:
+// the cut itself makes no text edit (it only marks the clipboard), so the whole
+// move happens at PASTE time. The host handler is thin glue over these
+// transforms, so exercising the same sequence proves the cut/paste behavior
+// without a live VS Code webview. Each case mirrors one user gesture:
+//   • same-document cut+paste (a MOVE): delete source first, then paste — the
+//     freed name is kept, and it is ONE combined edit (one undo step);
+//   • same-section cut+paste: a no-op the handler refuses (no delete/re-add);
+//   • cross-DOCUMENT cut+paste: paste into target text, delete from source text;
+//   • copy+paste: paste only, the source stays (and the copy is uniquified).
+// This is the cut/paste twin of dropEndToEnd.test.ts (the drag path).
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { getModel, findNode, invalidate } from '../src/host/SlddModel.js';
+import { buildRows } from '../src/host/rowBuilder.js';
+import { pasteEntry, deleteEntriesByName, resolveSectionForPaste } from '../src/host/structuralEdit.js';
+
+const archText = readFileSync(fileURLToPath(new URL('./fixtures/arch.sldd', import.meta.url)), 'utf8');
+
+function model(uri: string, text = archText) {
+  invalidate(uri);
+  return getModel(uri, 'arch.sldd', text);
+}
+function entry(uri: string, m: any, name: string) {
+  const id = buildRows(m).find((r: any) => r.Name?.label === name && !String(r.ID).startsWith('section:')).ID;
+  return findNode(uri, id);
+}
+function sectionOf(m: any, name: string) {
+  return m.children.find((s: any) => s.name === name);
+}
+
+describe('cut/paste end-to-end — same-document cut+paste is a MOVE that keeps the name', () => {
+  it('cuts an arch Data Interface and pastes into Design Data: gone from arch, kept name in design', () => {
+    const uri = 'test://cutpaste-move.sldd';
+    const m = model(uri);
+    const src = entry(uri, m, 'DataInterface');
+    // The cut marks the clipboard; NO text edit happens yet (lazy).
+    const payload = src.serialize() as Record<string, unknown>;
+    const sourceSection = 'arch';
+
+    // Paste into design (a different section) = same-document MOVE. applyPaste
+    // removes the source FIRST (in the same text), then re-resolves + pastes, so
+    // the whole thing is one combined edit and the freed name is retained.
+    const srcName = payload.name as string;
+    let text = deleteEntriesByName(archText, [srcName]);
+    invalidate(uri);
+    const m2 = getModel(uri, 'arch.sldd', text);
+    const design = sectionOf(m2, 'design');
+    const { newText } = pasteEntry(text, design, payload);
+    text = newText;
+
+    invalidate(uri);
+    const m3 = getModel(uri, 'arch.sldd', text);
+    const archNames = sectionOf(m3, 'arch').children.map((c: any) => c.name);
+    const moved = sectionOf(m3, 'design').children.find((c: any) => c.name === 'DataInterface');
+    expect(archNames).not.toContain('DataInterface'); // left arch
+    expect(moved).toBeTruthy();                        // arrived in design
+    expect(moved.isDerived).toBe(false);               // rebound to design (isderived rewritten)
+    // The freed name is kept (not uniquified), mirroring the drag-move contract.
+    expect(sourceSection).toBe('arch'); // sanity: distinct from the target section
+  });
+});
+
+describe('cut/paste end-to-end — same-section cut+paste is a no-op', () => {
+  it('pasting a cut back into its own section would just delete-and-re-add — the handler refuses', () => {
+    // applyPaste guards: if the cut is same-doc AND clip.sourceSection === the
+    // resolved target section, it clears the clipboard and makes no edit. Model
+    // that guard here: the source section equals the paste target section.
+    const uri = 'test://cutpaste-noop.sldd';
+    const m = model(uri);
+    const src = entry(uri, m, 'DataInterface');
+    const sourceSection = src.parent?.name;
+
+    // Resolve the paste target from the same entry's row — it lands in the same
+    // section the cut came from.
+    const target = resolveSectionForPaste(m, src, src.id);
+    expect(target.name).toBe(sourceSection); // same section → the no-op guard fires
+  });
+});
+
+describe('cut/paste end-to-end — cross-DOCUMENT cut+paste', () => {
+  it('cuts an entry in doc A and pastes into doc B: removed from A, present (uniquified) in B', () => {
+    const uriA = 'test://cutpaste-A.sldd';
+    const uriB = 'test://cutpaste-B.sldd';
+    const mA = model(uriA);
+    const src = entry(uriA, mA, 'DataInterface');
+    const payload = src.serialize() as Record<string, unknown>;
+
+    // Target doc B is a second copy of the fixture; paste into its design.
+    const textB = archText;
+    invalidate(uriB);
+    const mB = getModel(uriB, 'arch.sldd', textB);
+    const designB = sectionOf(mB, 'design');
+    const { newText: newB } = pasteEntry(textB, designB, payload);
+
+    // Source doc A: applyPaste deletes the moved entry via the source doc's own
+    // WorkspaceEdit (a separate, native undo step).
+    const newA = deleteEntriesByName(archText, ['DataInterface']);
+
+    invalidate(uriA);
+    invalidate(uriB);
+    const mA2 = getModel(uriA, 'arch.sldd', newA);
+    const mB2 = getModel(uriB, 'arch.sldd', newB);
+    expect(sectionOf(mA2, 'arch').children.map((c: any) => c.name)).not.toContain('DataInterface');
+    // B already holds "DataInterface" (it's a copy of the fixture), so the paste
+    // uniquifies to "DataInterface1" — cross-doc names aren't freed on the target.
+    expect(sectionOf(mB2, 'design').children.map((c: any) => c.name)).toContain('DataInterface1');
+  });
+});
+
+describe('cut/paste end-to-end — copy+paste leaves the source and uniquifies', () => {
+  it('copies an arch Data Interface into design: still in arch, duplicated as a uniquified design entry', () => {
+    const uri = 'test://cutpaste-copy.sldd';
+    const m = model(uri);
+    const src = entry(uri, m, 'DataInterface');
+    const payload = src.serialize() as Record<string, unknown>;
+    const design = sectionOf(m, 'design');
+
+    // Copy = paste only, no source delete.
+    const { newText } = pasteEntry(archText, design, payload);
+
+    invalidate(uri);
+    const m2 = getModel(uri, 'arch.sldd', newText);
+    expect(sectionOf(m2, 'arch').children.map((c: any) => c.name)).toContain('DataInterface'); // source stays
+    const copy = sectionOf(m2, 'design').children.find((c: any) => c.name === 'DataInterface1');
+    expect(copy).toBeTruthy();          // uniquified, since the source still holds the name
+    expect(copy.isDerived).toBe(false); // rebound to design
+  });
+
+  it('a copy stays on the clipboard for re-paste, producing a second uniquified entry', () => {
+    // Copy mode does not clear the clipboard, so the same payload can paste
+    // twice: the target section uniquifies each insertion independently.
+    const uri = 'test://cutpaste-copy2.sldd';
+    const m = model(uri);
+    const src = entry(uri, m, 'DataInterface');
+    const payload = src.serialize() as Record<string, unknown>;
+
+    let text = archText;
+    invalidate(uri);
+    let mi = getModel(uri, 'arch.sldd', text);
+    ({ newText: text } = pasteEntry(text, sectionOf(mi, 'design'), payload));
+    invalidate(uri);
+    mi = getModel(uri, 'arch.sldd', text);
+    ({ newText: text } = pasteEntry(text, sectionOf(mi, 'design'), payload));
+
+    invalidate(uri);
+    const names = sectionOf(getModel(uri, 'arch.sldd', text), 'design').children.map((c: any) => c.name);
+    expect(names).toContain('DataInterface1');
+    expect(names).toContain('DataInterface2'); // second paste uniquifies again
+  });
+});
diff --git a/test/deleteEntriesByName.test.ts b/test/deleteEntriesByName.test.ts
new file mode 100644
index 0000000..9b87be2
--- /dev/null
+++ b/test/deleteEntriesByName.test.ts
@@ -0,0 +1,52 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// deleteEntriesByName is the source-side of a MOVE drop: after the payloads are
+// pasted into the target, the dragged entries are removed from the SOURCE
+// document by name. It must work purely on text (the source may be a different
+// document than the target), remove each named top-level entry, and leave the
+// rest byte-valid — deleting several at once without offset drift.
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { getModel, invalidate } from '../src/host/SlddModel.js';
+import { deleteEntriesByName } from '../src/host/structuralEdit.js';
+
+const archText = readFileSync(fileURLToPath(new URL('./fixtures/arch.sldd', import.meta.url)), 'utf8');
+
+describe('deleteEntriesByName', () => {
+  it('removes a single named entry, leaving valid JSON without it', () => {
+    const uri = 'test://del-one.sldd';
+    invalidate(uri);
+    const before = getModel(uri, 'arch.sldd', archText);
+    const archBefore = before.children.find((s: any) => s.name === 'arch').children.map((c: any) => c.name);
+    expect(archBefore).toContain('DataInterface');
+
+    const newText = deleteEntriesByName(archText, ['DataInterface']);
+    expect(() => JSON.parse(newText)).not.toThrow();
+
+    invalidate(uri);
+    const after = getModel(uri, 'arch.sldd', newText);
+    const archAfter = after.children.find((s: any) => s.name === 'arch').children.map((c: any) => c.name);
+    expect(archAfter).not.toContain('DataInterface');
+  });
+
+  it('removes multiple named entries in one pass without offset drift', () => {
+    const uri = 'test://del-many.sldd';
+    const newText = deleteEntriesByName(archText, ['DataInterface', 'NumericType', 'ValueType']);
+    expect(() => JSON.parse(newText)).not.toThrow();
+
+    invalidate(uri);
+    const after = getModel(uri, 'arch.sldd', newText);
+    const allNames = after.children.flatMap((s: any) => s.children.map((c: any) => c.name));
+    expect(allNames).not.toContain('DataInterface');
+    expect(allNames).not.toContain('NumericType');
+    expect(allNames).not.toContain('ValueType');
+  });
+
+  it('ignores names that are not present (no throw, no change to others)', () => {
+    const newText = deleteEntriesByName(archText, ['DoesNotExist']);
+    expect(() => JSON.parse(newText)).not.toThrow();
+    // Nothing removed → text unchanged.
+    expect(newText).toBe(archText);
+  });
+});
diff --git a/test/dragMode.test.ts b/test/dragMode.test.ts
new file mode 100644
index 0000000..179bc39
--- /dev/null
+++ b/test/dragMode.test.ts
@@ -0,0 +1,57 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// The copy-vs-move drag modifier is PLATFORM-specific, and it must match the OS
+// convention exactly: the browser derives the native dropEffect from the OS
+// modifier, so requesting an effect the OS modifier doesn't grant makes the
+// drop silently fail (dropEffect forced to 'none', no drop event). These tests
+// pin the convention for every platform — including the ones we can't run
+// interactively — so the mapping can't regress unnoticed.
+import { describe, it, expect } from 'vitest';
+import { isMacPlatform, dragModeFromModifiers } from '../src/webview/dragMode.js';
+
+describe('isMacPlatform — recognizes Apple platform strings', () => {
+  it('is true for the desktop navigator.platform value', () => {
+    expect(isMacPlatform('MacIntel')).toBe(true);
+  });
+  it('is true for the userAgentData platform value', () => {
+    expect(isMacPlatform('macOS')).toBe(true);
+  });
+  it('is true for iPad/iPhone', () => {
+    expect(isMacPlatform('iPad')).toBe(true);
+    expect(isMacPlatform('iPhone')).toBe(true);
+  });
+  it('is false for Windows and Linux', () => {
+    expect(isMacPlatform('Win32')).toBe(false);
+    expect(isMacPlatform('Linux x86_64')).toBe(false);
+  });
+  it('is false for an empty/unknown platform', () => {
+    expect(isMacPlatform('')).toBe(false);
+  });
+});
+
+describe('dragModeFromModifiers — macOS uses Option (Alt) for copy', () => {
+  it('Option held = copy', () => {
+    expect(dragModeFromModifiers('MacIntel', { altKey: true, ctrlKey: false })).toBe('copy');
+  });
+  it('no modifier = move', () => {
+    expect(dragModeFromModifiers('MacIntel', { altKey: false, ctrlKey: false })).toBe('move');
+  });
+  it('Ctrl does NOT copy on macOS (a plain move; Cmd/Ctrl are not the copy key)', () => {
+    expect(dragModeFromModifiers('MacIntel', { altKey: false, ctrlKey: true })).toBe('move');
+  });
+});
+
+describe('dragModeFromModifiers — Windows/Linux use Ctrl for copy', () => {
+  it('Ctrl held = copy on Windows', () => {
+    expect(dragModeFromModifiers('Win32', { altKey: false, ctrlKey: true })).toBe('copy');
+  });
+  it('Ctrl held = copy on Linux', () => {
+    expect(dragModeFromModifiers('Linux x86_64', { altKey: false, ctrlKey: true })).toBe('copy');
+  });
+  it('no modifier = move on Windows', () => {
+    expect(dragModeFromModifiers('Win32', { altKey: false, ctrlKey: false })).toBe('move');
+  });
+  it('Alt does NOT copy on Windows (it is not the copy modifier there)', () => {
+    expect(dragModeFromModifiers('Win32', { altKey: true, ctrlKey: false })).toBe('move');
+  });
+});
diff --git a/test/dragState.test.ts b/test/dragState.test.ts
new file mode 100644
index 0000000..24eaebf
--- /dev/null
+++ b/test/dragState.test.ts
@@ -0,0 +1,74 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// The drag register is the host-side singleton that holds the rows currently
+// being dragged, mirroring the clipboard singleton. HTML5 dataTransfer does not
+// survive the webview iframe boundary, so the host holds the payloads and
+// broadcasts a lightweight descriptor (source metadata + per-item class/kind,
+// but NOT the full payloads) to every webview, which each run dropDecision on
+// dragover. Drop reads the payloads back from the register.
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  setDrag,
+  getDrag,
+  clearDrag,
+  dragDescriptor,
+  type DragRegisterItem,
+} from '../src/host/dragState.js';
+
+const item = (name: string, className: string, arrayClass: string, kind: string): DragRegisterItem => ({
+  payload: { name, metadata: { uuid: 'u-' + name }, value: arrayClass ? { _array_class: arrayClass } : 1 },
+  className,
+  arrayClass,
+  kind,
+  isMatlabVariable: !arrayClass,
+});
+
+describe('drag register', () => {
+  beforeEach(() => clearDrag());
+
+  it('is empty until a drag starts', () => {
+    expect(getDrag()).toBeNull();
+    expect(dragDescriptor()).toBeNull();
+  });
+
+  it('holds the dragged items and their source', () => {
+    const items = [item('Bus', 'Simulink.Bus', 'Simulink.Bus', 'Bus')];
+    setDrag('a.sldd', 'design', 'Design Data', false, items);
+    const d = getDrag();
+    expect(d).not.toBeNull();
+    expect(d!.sourceDocUri).toBe('a.sldd');
+    expect(d!.sourceSection).toBe('design');
+    expect(d!.items).toHaveLength(1);
+    expect(d!.items[0].payload).toEqual(items[0].payload);
+  });
+
+  it('descriptor exposes source + per-item class/kind but NOT the payloads', () => {
+    setDrag('a.sldd', 'arch', 'Architectural Data', true, [
+      item('DataInterface', 'Simulink.Bus', 'Simulink.Bus', 'Data Interface'),
+    ]);
+    const desc = dragDescriptor();
+    expect(desc).toEqual({
+      docUri: 'a.sldd',
+      sectionName: 'arch',
+      sectionLabel: 'Architectural Data',
+      isDerived: true,
+      items: [
+        {
+          className: 'Simulink.Bus',
+          arrayClass: 'Simulink.Bus',
+          kind: 'Data Interface',
+          isMatlabVariable: false,
+        },
+      ],
+    });
+    // The descriptor must not leak the full payloads to the webview.
+    expect(JSON.stringify(desc)).not.toContain('_array_class');
+  });
+
+  it('clears', () => {
+    setDrag('a.sldd', 'design', 'Design Data', false, [item('X', 'Simulink.Bus', 'Simulink.Bus', 'Bus')]);
+    clearDrag();
+    expect(getDrag()).toBeNull();
+    expect(dragDescriptor()).toBeNull();
+  });
+});
diff --git a/test/dropComplete.test.ts b/test/dropComplete.test.ts
new file mode 100644
index 0000000..0d13409
--- /dev/null
+++ b/test/dropComplete.test.ts
@@ -0,0 +1,72 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// pasteEntries is the drop-completion transform: a drop is exactly a paste of
+// the dragged payloads into the target section (a move additionally deletes the
+// sources, handled by the host via the existing deleteEntry path). This covers
+// the multi-item case a drop introduces — pasting several entries into one text
+// in a single edit, each getting a unique name across the growing namespace.
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { getModel, invalidate } from '../src/host/SlddModel.js';
+import { buildRows } from '../src/host/rowBuilder.js';
+import { findNode } from '../src/host/SlddModel.js';
+import { pasteEntries } from '../src/host/structuralEdit.js';
+
+const archText = readFileSync(fileURLToPath(new URL('./fixtures/arch.sldd', import.meta.url)), 'utf8');
+
+function model(uri: string) {
+  invalidate(uri);
+  return getModel(uri, 'arch.sldd', archText);
+}
+function payloadOf(uri: string, m: any, name: string) {
+  const id = buildRows(m).find((r: any) => r.Name?.label === name && !String(r.ID).startsWith('section:')).ID;
+  return findNode(uri, id).serialize() as Record<string, unknown>;
+}
+
+describe('pasteEntries — multi-item drop completion', () => {
+  it('pastes two entries into design, each uniquely named across the namespace', () => {
+    const uri = 'test://drop-multi.sldd';
+    const m = model(uri);
+    const bus = payloadOf(uri, m, 'DataInterface');
+    const nt = payloadOf(uri, m, 'NumericType');
+    const design = m.children.find((s: any) => s.name === 'design');
+
+    const { newText, selectIds } = pasteEntries(archText, design, [bus, nt]);
+    expect(() => JSON.parse(newText)).not.toThrow();
+    expect(selectIds).toHaveLength(2);
+
+    invalidate(uri);
+    const m2 = getModel(uri, 'arch.sldd', newText);
+    const designNames = m2.children.find((s: any) => s.name === 'design').children.map((c: any) => c.name);
+    expect(designNames).toContain('DataInterface1');
+    expect(designNames).toContain('NumericType1');
+    // Distinct names — the second paste saw the first already in the namespace.
+    expect(new Set(designNames).size).toBe(designNames.length);
+  });
+
+  it('rejects the whole drop if any item is disallowed in the target', () => {
+    const uri = 'test://drop-reject.sldd';
+    const m = model(uri);
+    const bus = payloadOf(uri, m, 'DataInterface');
+    const svc = payloadOf(uri, m, 'ServiceInterface'); // Simulink.ServiceBus, design-illegal
+    const design = m.children.find((s: any) => s.name === 'design');
+
+    expect(() => pasteEntries(archText, design, [bus, svc])).toThrow(/not allowed|ServiceBus/i);
+  });
+
+  it('a single-item drop matches pasteEntry (one entry, one select id)', () => {
+    const uri = 'test://drop-single.sldd';
+    const m = model(uri);
+    const bus = payloadOf(uri, m, 'DataInterface');
+    const arch = m.children.find((s: any) => s.name === 'arch');
+
+    const { newText, selectIds } = pasteEntries(archText, arch, [bus]);
+    expect(selectIds).toHaveLength(1);
+    invalidate(uri);
+    const m2 = getModel(uri, 'arch.sldd', newText);
+    const copy = m2.children.find((s: any) => s.name === 'arch').children.find((c: any) => c.name === 'DataInterface1');
+    expect(copy).toBeTruthy();
+    expect((copy.metadata as any).isderived).toBe('1');
+  });
+});
diff --git a/test/dropDecision.test.ts b/test/dropDecision.test.ts
new file mode 100644
index 0000000..f467fe1
--- /dev/null
+++ b/test/dropDecision.test.ts
@@ -0,0 +1,193 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// dropDecision is the PURE predictor behind the drag-and-drop cursor and hover
+// tooltip. The bottom line it must honor: drag-drop mirrors cut/copy-paste — if
+// you can cut/copy you can drag, and if you can paste you can drop. So its
+// accept/reject logic mirrors pasteEntry's allow-check exactly, and its labels
+// mirror the Kind an entry shows AFTER the paste (a pasted entry loses its
+// SystemComposer classification, so a derived Bus becomes a "Data Interface").
+import { describe, it, expect } from 'vitest';
+import { dropDecision } from '../src/webview/dropDecision.js';
+
+// Allow-lists mirror SectionNode.ALLOWED_TYPES (only the classes these tests use).
+const DESIGN_ALLOWED = [
+  'Simulink.Signal',
+  'Simulink.Bus',
+  'Simulink.ConnectionBus',
+  'Simulink.Parameter',
+  'Simulink.ValueType',
+  'Simulink.NumericType',
+];
+const ARCH_ALLOWED = [
+  'Simulink.Signal',
+  'Simulink.Bus',
+  'Simulink.ConnectionBus',
+  'Simulink.ServiceBus',
+  'Simulink.ValueType',
+  'Simulink.NumericType',
+];
+
+function designSource(items: any[], docUri = 'a.sldd') {
+  return { docUri, sectionName: 'design', sectionLabel: 'Design Data', isDerived: false, items };
+}
+function archSource(items: any[], docUri = 'a.sldd') {
+  return { docUri, sectionName: 'arch', sectionLabel: 'Architectural Data', isDerived: true, items };
+}
+function designTarget(docUri = 'a.sldd') {
+  return {
+    docUri,
+    sectionName: 'design',
+    sectionLabel: 'Design Data',
+    isDerived: false,
+    allowedTypes: DESIGN_ALLOWED,
+  };
+}
+function archTarget(docUri = 'a.sldd') {
+  return { docUri, sectionName: 'arch', sectionLabel: 'Architectural Data', isDerived: true, allowedTypes: ARCH_ALLOWED };
+}
+
+// Convenience item builders.
+const bus = (kind = 'Bus') => ({ className: 'Simulink.Bus', arrayClass: 'Simulink.Bus', kind, isMatlabVariable: false });
+const dataInterface = () => bus('Data Interface');
+const param = () => ({
+  className: 'Simulink.Parameter',
+  arrayClass: 'Simulink.Parameter',
+  kind: 'Simulink Parameter',
+  isMatlabVariable: false,
+});
+const service = () => ({
+  className: 'Simulink.ServiceBus',
+  arrayClass: 'Simulink.ServiceBus',
+  kind: 'Service Interface',
+  isMatlabVariable: false,
+});
+const matlabVar = (kind = 'MATLAB Variable') => ({
+  className: 'double',
+  arrayClass: '',
+  kind,
+  isMatlabVariable: true,
+});
+
+describe('dropDecision — accept/reject mirrors pasteEntry allow-check', () => {
+  it('rejects a Simulink.Parameter dropped into Architectural Data with a reason tooltip', () => {
+    const d = dropDecision(designSource([param()], 'b.sldd'), archTarget('a.sldd'), 'copy');
+    expect(d.canDrop).toBe(false);
+    expect(d.cursor).toBe('no-drop');
+    expect(d.tooltip).toBe('Simulink Parameter cannot be in Architectural Data');
+  });
+
+  it('rejects a ServiceInterface dropped into Design Data', () => {
+    const d = dropDecision(archSource([service()], 'b.sldd'), designTarget('a.sldd'), 'move');
+    expect(d.canDrop).toBe(false);
+    expect(d.cursor).toBe('no-drop');
+    expect(d.tooltip).toBe('Service Interface cannot be in Design Data');
+  });
+
+  it('accepts a Bus into Architectural Data (allowed type)', () => {
+    const d = dropDecision(designSource([bus()], 'b.sldd'), archTarget('a.sldd'), 'copy');
+    expect(d.canDrop).toBe(true);
+  });
+
+  it('accepts a MATLAB variable into any section (empty array-class skips the check)', () => {
+    // A MATLAB variable has no _array_class, so pasteEntry never rejects it —
+    // even into arch, where it becomes a Constant.
+    const d = dropDecision(designSource([matlabVar()], 'b.sldd'), archTarget('a.sldd'), 'copy');
+    expect(d.canDrop).toBe(true);
+  });
+});
+
+describe('dropDecision — dynamic can-drop tooltip mirrors the post-paste Kind', () => {
+  it('design Bus -> another design section in COPY mode reads "Copy Bus"', () => {
+    const d = dropDecision(designSource([bus()], 'b.sldd'), designTarget('a.sldd'), 'copy');
+    expect(d.canDrop).toBe(true);
+    expect(d.tooltip).toBe('Copy Bus');
+  });
+
+  it('design Bus -> another design section in MOVE mode reads "Move Bus"', () => {
+    const d = dropDecision(designSource([bus()], 'b.sldd'), designTarget('a.sldd'), 'move');
+    expect(d.canDrop).toBe(true);
+    expect(d.tooltip).toBe('Move Bus');
+  });
+
+  it('design Bus -> arch reads "Convert Bus to Data Interface"', () => {
+    const d = dropDecision(designSource([bus()], 'b.sldd'), archTarget('a.sldd'), 'copy');
+    expect(d.canDrop).toBe(true);
+    expect(d.tooltip).toBe('Convert Bus to Data Interface');
+  });
+
+  it('arch Data Interface -> design reads "Convert Data Interface to Bus"', () => {
+    const d = dropDecision(archSource([dataInterface()], 'b.sldd'), designTarget('a.sldd'), 'move');
+    expect(d.canDrop).toBe(true);
+    expect(d.tooltip).toBe('Convert Data Interface to Bus');
+  });
+
+  it('a MATLAB variable design -> arch reads "Convert MATLAB Variable to Constant"', () => {
+    const d = dropDecision(designSource([matlabVar()], 'b.sldd'), archTarget('a.sldd'), 'copy');
+    expect(d.tooltip).toBe('Convert MATLAB Variable to Constant');
+  });
+});
+
+describe('dropDecision — cursor reflects the drag mode', () => {
+  it('copy mode yields a copy cursor', () => {
+    expect(dropDecision(designSource([bus()], 'b.sldd'), archTarget('a.sldd'), 'copy').cursor).toBe('copy');
+  });
+  it('move mode yields a move cursor', () => {
+    expect(dropDecision(designSource([bus()], 'b.sldd'), designTarget('a.sldd'), 'move').cursor).toBe('move');
+  });
+});
+
+describe('dropDecision — same-section move is a no-op', () => {
+  it('same doc + same section + move is a no-op (no delete/re-add)', () => {
+    const d = dropDecision(designSource([bus()], 'a.sldd'), designTarget('a.sldd'), 'move');
+    expect(d.noop).toBe(true);
+    expect(d.canDrop).toBe(false);
+    expect(d.cursor).toBe('no-drop');
+  });
+
+  it('same doc + same section + COPY still duplicates (not a no-op)', () => {
+    const d = dropDecision(designSource([bus()], 'a.sldd'), designTarget('a.sldd'), 'copy');
+    expect(d.noop).toBe(false);
+    expect(d.canDrop).toBe(true);
+    expect(d.tooltip).toBe('Copy Bus');
+  });
+
+  it('cross-doc same-section-name move is NOT a no-op', () => {
+    const d = dropDecision(designSource([bus()], 'a.sldd'), designTarget('b.sldd'), 'move');
+    expect(d.noop).toBe(false);
+    expect(d.canDrop).toBe(true);
+  });
+});
+
+describe('dropDecision — multi-select: any rejected rejects all', () => {
+  it('a Bus + a Parameter dropped into arch is rejected (the Parameter has no home)', () => {
+    const d = dropDecision(designSource([bus(), param()], 'b.sldd'), archTarget('a.sldd'), 'copy');
+    expect(d.canDrop).toBe(false);
+    expect(d.tooltip).toBe('Simulink Parameter cannot be in Architectural Data');
+  });
+
+  it('multiple allowed items use a count label', () => {
+    const d = dropDecision(designSource([bus(), bus()], 'b.sldd'), archTarget('a.sldd'), 'copy');
+    expect(d.canDrop).toBe(true);
+    expect(d.tooltip).toBe('Convert 2 items to Architectural Data');
+  });
+
+  it('multiple allowed same-shape items in COPY mode use a count label', () => {
+    const d = dropDecision(designSource([bus(), bus()], 'b.sldd'), designTarget('a.sldd'), 'copy');
+    expect(d.canDrop).toBe(true);
+    expect(d.tooltip).toBe('Copy 2 items');
+  });
+
+  it('multiple allowed same-shape items in MOVE mode use a count label', () => {
+    const d = dropDecision(designSource([bus(), bus()], 'b.sldd'), designTarget('a.sldd'), 'move');
+    expect(d.canDrop).toBe(true);
+    expect(d.tooltip).toBe('Move 2 items');
+  });
+});
+
+describe('dropDecision — empty payload', () => {
+  it('no items cannot drop', () => {
+    const d = dropDecision(designSource([], 'b.sldd'), archTarget('a.sldd'), 'copy');
+    expect(d.canDrop).toBe(false);
+    expect(d.cursor).toBe('no-drop');
+  });
+});
diff --git a/test/dropEndToEnd.test.ts b/test/dropEndToEnd.test.ts
new file mode 100644
index 0000000..190b9b1
--- /dev/null
+++ b/test/dropEndToEnd.test.ts
@@ -0,0 +1,178 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// End-to-end drop flows, modeling exactly what SlddTextEditorProvider.applyDrop
+// does with the pure transforms — the host handler is thin glue over these, so
+// exercising the same sequence proves the drag-and-drop behavior without a live
+// VS Code webview. Each case mirrors one user gesture:
+//   • cross-section MOVE within a doc: delete sources, then paste into target;
+//   • cross-section COPY: paste only, sources stay;
+//   • cross-DOCUMENT move: paste into target text, delete from source text;
+//   • the predicted decision (dropDecision) agrees with what the flow does.
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { getModel, findNode, invalidate } from '../src/host/SlddModel.js';
+import { buildRows } from '../src/host/rowBuilder.js';
+import { pasteEntries, deleteEntriesByName, resolveSectionForPaste } from '../src/host/structuralEdit.js';
+import { sectionRules } from '../src/host/sectionRules.js';
+import { dropDecision, type DragItem } from '../src/webview/dropDecision.js';
+
+const archText = readFileSync(fileURLToPath(new URL('./fixtures/arch.sldd', import.meta.url)), 'utf8');
+
+function model(uri: string, text = archText) {
+  invalidate(uri);
+  return getModel(uri, 'arch.sldd', text);
+}
+function entry(uri: string, m: any, name: string) {
+  const id = buildRows(m).find((r: any) => r.Name?.label === name && !String(r.ID).startsWith('section:')).ID;
+  return findNode(uri, id);
+}
+function sectionOf(m: any, name: string) {
+  return m.children.find((s: any) => s.name === name);
+}
+// Build the DragItem the webview would see for a live node (mirrors applyDragStart).
+function dragItemOf(node: any): DragItem {
+  const payload = node.serialize() as any;
+  const arrayClass = (payload.value && typeof payload.value === 'object' && payload.value._array_class) || '';
+  return {
+    className: node.className ?? '',
+    arrayClass,
+    kind: node.kind ?? '',
+    isMatlabVariable: !arrayClass,
+  };
+}
+
+describe('drop end-to-end — cross-section MOVE within one document', () => {
+  it('moves an arch Data Interface into Design Data: gone from arch, a genuine design entry keeping its name', () => {
+    const uri = 'test://e2e-move.sldd';
+    const m = model(uri);
+    const src = entry(uri, m, 'DataInterface');
+    const payload = src.serialize() as Record<string, unknown>;
+
+    // Predict first — the webview would show "Convert Data Interface to Bus".
+    const rules = sectionRules(m);
+    const designRule = rules.find((r) => r.sectionName === 'design')!;
+    const decision = dropDecision(
+      { docUri: uri, sectionName: 'arch', sectionLabel: 'Architectural Data', isDerived: true, items: [dragItemOf(src)] },
+      { docUri: uri, ...designRule },
+      'move',
+    );
+    expect(decision.canDrop).toBe(true);
+    expect(decision.tooltip).toBe('Convert Data Interface to Bus');
+
+    // Perform: same-doc move = delete source, then paste into target text.
+    let text = deleteEntriesByName(archText, ['DataInterface']);
+    invalidate(uri);
+    const m2 = getModel(uri, 'arch.sldd', text);
+    const design = sectionOf(m2, 'design');
+    const { newText } = pasteEntries(text, design, [payload]);
+    text = newText;
+
+    invalidate(uri);
+    const m3 = getModel(uri, 'arch.sldd', text);
+    const archNames = sectionOf(m3, 'arch').children.map((c: any) => c.name);
+    const designSection = sectionOf(m3, 'design');
+    const moved = designSection.children.find((c: any) => c.name === 'DataInterface');
+    expect(archNames).not.toContain('DataInterface'); // left arch
+    expect(moved).toBeTruthy(); // arrived in design
+    expect(moved.isDerived).toBe(false); // now a genuine design entry (isderived rewritten)
+    // A MOVE frees the source name, so the paste keeps it ("DataInterface"),
+    // matching cut+paste — the same entity keeps a stable name. The document's
+    // SystemComposer catalog is keyed by NAME and this editor only rewrites the
+    // entries array (never the interfaceDictionary), so that kept name is still
+    // classified as a Data Interface. Shedding the classification is what a COPY
+    // (below) does for free by uniquifying the name to "DataInterface1".
+    expect(moved.className).toBe('Simulink.Bus'); // the underlying class is unchanged by the move
+    expect(moved.kind).toBe('Data Interface'); // name-keyed catalog still classifies it
+  });
+});
+
+describe('drop end-to-end — cross-section COPY leaves the source', () => {
+  it('copies an arch Data Interface into design: still in arch, duplicated in design', () => {
+    const uri = 'test://e2e-copy.sldd';
+    const m = model(uri);
+    const src = entry(uri, m, 'DataInterface');
+    const payload = src.serialize() as Record<string, unknown>;
+    const design = sectionOf(m, 'design');
+
+    // Copy = paste only, no source delete.
+    const { newText } = pasteEntries(archText, design, [payload]);
+
+    invalidate(uri);
+    const m2 = getModel(uri, 'arch.sldd', newText);
+    expect(sectionOf(m2, 'arch').children.map((c: any) => c.name)).toContain('DataInterface');
+    const copy = sectionOf(m2, 'design').children.find((c: any) => c.name === 'DataInterface1');
+    expect(copy).toBeTruthy();
+    // The source still holds "DataInterface", so the copy is uniquified to
+    // "DataInterface1" — a name the SystemComposer catalog doesn't classify. With
+    // no name-keyed classification, the Kind falls back to the class: a Bus. This
+    // is the exact contrast with the MOVE case, where the freed name is retained.
+    expect(copy.className).toBe('Simulink.Bus');
+    expect(copy.kind).toBe('Bus');
+  });
+});
+
+describe('drop end-to-end — cross-DOCUMENT move', () => {
+  it('moves an entry from doc A into doc B: removed from A, present in B', () => {
+    const uriA = 'test://e2e-A.sldd';
+    const uriB = 'test://e2e-B.sldd';
+    const mA = model(uriA);
+    const src = entry(uriA, mA, 'DataInterface');
+    const payload = src.serialize() as Record<string, unknown>;
+
+    // Target doc B is a second copy of the fixture; paste into its design.
+    const textB = archText;
+    invalidate(uriB);
+    const mB = getModel(uriB, 'arch.sldd', textB);
+    const designB = sectionOf(mB, 'design');
+    const { newText: newB } = pasteEntries(textB, designB, [payload]);
+
+    // Source doc A: delete the moved entry (its own edit, cross-doc).
+    const newA = deleteEntriesByName(archText, ['DataInterface']);
+
+    invalidate(uriA);
+    invalidate(uriB);
+    const mA2 = getModel(uriA, 'arch.sldd', newA);
+    const mB2 = getModel(uriB, 'arch.sldd', newB);
+    expect(sectionOf(mA2, 'arch').children.map((c: any) => c.name)).not.toContain('DataInterface');
+    expect(sectionOf(mB2, 'design').children.map((c: any) => c.name)).toContain('DataInterface1');
+  });
+});
+
+describe('drop end-to-end — same-section move is a no-op', () => {
+  it('dropDecision refuses a same-doc same-section move (no delete/re-add)', () => {
+    const uri = 'test://e2e-noop.sldd';
+    const m = model(uri);
+    const src = entry(uri, m, 'DataInterface');
+    const rules = sectionRules(m);
+    const archRule = rules.find((r) => r.sectionName === 'arch')!;
+    const decision = dropDecision(
+      { docUri: uri, sectionName: 'arch', sectionLabel: 'Architectural Data', isDerived: true, items: [dragItemOf(src)] },
+      { docUri: uri, ...archRule },
+      'move',
+    );
+    expect(decision.noop).toBe(true);
+    expect(decision.canDrop).toBe(false);
+  });
+});
+
+describe('drop end-to-end — rejected drop is predicted and never performed', () => {
+  it('a ServiceInterface dropped into design is rejected, and pasteEntries would throw', () => {
+    const uri = 'test://e2e-reject.sldd';
+    const m = model(uri);
+    const svc = entry(uri, m, 'ServiceInterface');
+    const rules = sectionRules(m);
+    const designRule = rules.find((r) => r.sectionName === 'design')!;
+    const decision = dropDecision(
+      { docUri: uri, sectionName: 'arch', sectionLabel: 'Architectural Data', isDerived: true, items: [dragItemOf(svc)] },
+      { docUri: uri, ...designRule },
+      'copy',
+    );
+    expect(decision.canDrop).toBe(false);
+    expect(decision.tooltip).toBe('Service Interface cannot be in Design Data');
+
+    // And the host transform agrees: it would refuse the paste.
+    const design = sectionOf(m, 'design');
+    expect(() => pasteEntries(archText, design, [svc.serialize() as Record<string, unknown>])).toThrow();
+  });
+});
diff --git a/test/rowBuilder.test.ts b/test/rowBuilder.test.ts
index 890bca0..369c360 100644
--- a/test/rowBuilder.test.ts
+++ b/test/rowBuilder.test.ts
@@ -53,6 +53,53 @@ describe('buildRows host-side tree construction', () => {
   });
 });
 
+describe('clipboard affordance — stamps Name.clipboardMode on the cut/copied source row', () => {
+  it('marks the named entry in its section as "cut" when a clipMark cut is passed', () => {
+    const path = fixturePath('numeric_json.sldd');
+    const text = readFileSync(path, 'utf8');
+    const sldd = getModel('test://numeric_json-cut.sldd', 'numeric_json.sldd', text);
+    const rows = buildRows(sldd, undefined, { name: 'Number', section: 'design', mode: 'cut' });
+
+    const numberRow = rows.find((r) => r.Name && r.Name.label === 'Number');
+    expect(numberRow.Name.clipboardMode).toBe('cut');
+
+    // No other entry row carries the mark.
+    const others = rows.filter(
+      (r) => r.Name && typeof r.Name === 'object' && r.Name.label !== 'Number' && !String(r.ID).startsWith('section:'),
+    );
+    for (const r of others) expect(r.Name.clipboardMode).toBeUndefined();
+  });
+
+  it('marks the named entry as "copied" for a copy clipMark', () => {
+    const path = fixturePath('numeric_json.sldd');
+    const text = readFileSync(path, 'utf8');
+    const sldd = getModel('test://numeric_json-copy.sldd', 'numeric_json.sldd', text);
+    const rows = buildRows(sldd, undefined, { name: 'Number', section: 'design', mode: 'copy' });
+    const numberRow = rows.find((r) => r.Name && r.Name.label === 'Number');
+    expect(numberRow.Name.clipboardMode).toBe('copy');
+  });
+
+  it('does not stamp when the clipMark section does not match the entry’s section', () => {
+    const path = fixturePath('numeric_json.sldd');
+    const text = readFileSync(path, 'utf8');
+    const sldd = getModel('test://numeric_json-nomatch.sldd', 'numeric_json.sldd', text);
+    // "Number" lives in design, not in some other section.
+    const rows = buildRows(sldd, undefined, { name: 'Number', section: 'references', mode: 'cut' });
+    const numberRow = rows.find((r) => r.Name && r.Name.label === 'Number');
+    expect(numberRow.Name.clipboardMode).toBeUndefined();
+  });
+
+  it('stamps nothing when no clipMark is given (default behavior unchanged)', () => {
+    const path = fixturePath('numeric_json.sldd');
+    const text = readFileSync(path, 'utf8');
+    const sldd = getModel('test://numeric_json-none.sldd', 'numeric_json.sldd', text);
+    const rows = buildRows(sldd);
+    for (const r of rows) {
+      if (r.Name && typeof r.Name === 'object') expect(r.Name.clipboardMode).toBeUndefined();
+    }
+  });
+});
+
 describe('buildEntryRows capability flags (for the context menu)', () => {
   // Duck-typed nodes exercising the capability branches. capabilityFlags reads
   // isEntry, canAddChild(), and parent.canRemoveChild() defensively.
diff --git a/test/sectionRules.test.ts b/test/sectionRules.test.ts
new file mode 100644
index 0000000..73fe500
--- /dev/null
+++ b/test/sectionRules.test.ts
@@ -0,0 +1,39 @@
+// Copyright 2026 The MathWorks, Inc.
+//
+// sectionRules extracts, from a live model, the per-section facts the webview
+// needs to predict a drop with dropDecision (name, label, isDerived, allowed
+// types). It is posted to each webview so dragover can run entirely client-side.
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { getModel, invalidate } from '../src/host/SlddModel.js';
+import { sectionRules } from '../src/host/sectionRules.js';
+
+const archText = readFileSync(fileURLToPath(new URL('./fixtures/arch.sldd', import.meta.url)), 'utf8');
+
+describe('sectionRules', () => {
+  it('returns one rule per section with its allow-list and derived flag', () => {
+    const uri = 'test://rules.sldd';
+    invalidate(uri);
+    const m = getModel(uri, 'arch.sldd', archText);
+    const rules = sectionRules(m);
+
+    const design = rules.find((r) => r.sectionName === 'design');
+    const arch = rules.find((r) => r.sectionName === 'arch');
+    expect(design).toBeTruthy();
+    expect(arch).toBeTruthy();
+
+    // Derived flag distinguishes arch from design.
+    expect(design!.isDerived).toBe(false);
+    expect(arch!.isDerived).toBe(true);
+
+    // Allow-lists mirror SectionNode.ALLOWED_TYPES.
+    expect(design!.allowedTypes).toContain('Simulink.Parameter');
+    expect(arch!.allowedTypes).not.toContain('Simulink.Parameter');
+    expect(arch!.allowedTypes).toContain('Simulink.ServiceBus');
+
+    // A human-readable label for the tooltip.
+    expect(design!.sectionLabel).toBe('Design Data');
+    expect(arch!.sectionLabel).toBe('Architectural Data');
+  });
+});
diff --git a/test/structuralIndex.test.ts b/test/structuralIndex.test.ts
index ad5184d..651db98 100644
--- a/test/structuralIndex.test.ts
+++ b/test/structuralIndex.test.ts
@@ -102,3 +102,108 @@ describe('buildGraphSource', () => {
     expect(s.type).toBe('sldd');
   });
 });
+
+// A minimal but REAL project store (resources/project/**/*.xml), mirroring the
+// hash-linked layout parseProject expects. Kept local so this test drives the
+// buildGraphSource -> parseProject integration end-to-end with genuine input,
+// not a stub: two member files under two folders, plus a project->project
+// reference, so we can assert basenames, folder filtering, and refs.
+function projectStore(): Record<string, string> {
+  const DECL = '<?xml version="1.0" encoding="UTF-8"?>';
+  const info = (body: string): string => `${DECL}\n${body}`;
+  const p = (rel: string): string => `resources/project/${rel}`;
+  const store: Record<string, string> = {};
+
+  // root/ entry pointers.
+  store[p('root/AAAAAAAAAAAAAAAAAAAAAAAAAAAAp.xml')] = info('<Info location="ProjectData" type="Info"/>');
+  store[p('root/AAAAAAAAAAAAAAAAAAAAAAAAAAAAd.xml')] = info('<Info Name="Widget"/>');
+  store[p('root/BBBBBBBBBBBBBBBBBBBBBBBBBBBBp.xml')] = info('<Info location="Root" type="Files"/>');
+  // A genuine project->project reference living directly in root.
+  store[p('root/GGGGGGGGGGGGGGGGGGGGGGGGGGGGp.xml')] = info('<Info location="ref-uuid" type="Reference"/>');
+  store[p('root/GGGGGGGGGGGGGGGGGGGGGGGGGGGGd.xml')] = info('<Info Ref="SharedLib" Type="Relative"/>');
+  // A reference whose def carries no Ref → its name is null, so buildGraphSource
+  // falls back to the id (the pointer location). Exercises `r.name ?? r.id`.
+  store[p('root/HHHHHHHHHHHHHHHHHHHHHHHHHHHHp.xml')] = info('<Info location="nameless-uuid" type="Reference"/>');
+  store[p('root/HHHHHHHHHHHHHHHHHHHHHHHHHHHHd.xml')] = info('<Info Type="Relative"/>');
+
+  // Files collection (hash BBB...): one File 'models', one File 'helper.m'.
+  const files = 'BBBBBBBBBBBBBBBBBBBBBBBBBBBB';
+  store[p(`${files}/DDDDDDDDDDDDDDDDDDDDDDDDDDDDp.xml`)] = info('<Info location="models" type="File"/>');
+  store[p(`${files}/DDDDDDDDDDDDDDDDDDDDDDDDDDDDd.xml`)] = info('<Info/>');
+  store[p(`${files}/EEEEEEEEEEEEEEEEEEEEEEEEEEEEp.xml`)] = info('<Info location="helper.m" type="File"/>');
+  store[p(`${files}/EEEEEEEEEEEEEEEEEEEEEEEEEEEEd.xml`)] = info('<Info/>');
+
+  // 'models' File entity's own dir (hash DDD...) carries a DIR_SIGNIFIER → folder.
+  const models = 'DDDDDDDDDDDDDDDDDDDDDDDDDDDD';
+  store[p(`${models}/FFFFFFFFFFFFFFFFFFFFFFFFFFFFp.xml`)] = info('<Info location="1" type="DIR_SIGNIFIER"/>');
+  store[p(`${models}/FFFFFFFFFFFFFFFFFFFFFFFFFFFFd.xml`)] = info('<Info/>');
+
+  return store;
+}
+
+describe('buildGraphSource — .prj project branch', () => {
+  it('maps a project to member basenames (files only, folders excluded) and its references', () => {
+    const s = buildGraphSource({
+      uriString: 'file:///proj/Widget.prj',
+      path: '/proj/Widget.prj',
+      projectFiles: projectStore(),
+    });
+
+    expect(s.type).toBe('project');
+    // helper.m is a File (basename); 'models' is a folder and must be excluded.
+    expect(s.projectFiles).toContain('helper.m');
+    expect(s.projectFiles).not.toContain('models');
+    // The project->project reference name is surfaced.
+    expect(s.projectRefs).toContain('SharedLib');
+    // A reference with no resolvable name falls back to its id (location).
+    expect(s.projectRefs).toContain('nameless-uuid');
+    // Base GraphSource fields stay intact.
+    expect(s.slddRefs).toEqual([]);
+    expect(s.modelRefs).toEqual([]);
+  });
+
+  it('returns an empty project node when a .prj has no projectFiles map', () => {
+    // Without projectFiles the project branch is skipped and the base node
+    // (no members/refs) is returned — never a throw.
+    const s = buildGraphSource({ uriString: 'file:///p.prj', path: '/p.prj' });
+    expect(s.type).toBe('project');
+    expect(s.projectFiles).toBeUndefined();
+    expect(s.projectRefs).toBeUndefined();
+    expect(s.dataDictionary).toBeNull();
+  });
+
+  it('tolerates an empty project store, yielding no members and no refs', () => {
+    const s = buildGraphSource({
+      uriString: 'file:///empty/Empty.prj',
+      path: '/empty/Empty.prj',
+      projectFiles: {},
+    });
+    expect(s.type).toBe('project');
+    expect(s.projectFiles).toEqual([]);
+    expect(s.projectRefs).toEqual([]);
+  });
+});
+
+describe('buildGraphSource — error path returns the base node', () => {
+  it('returns the base node (no throw) when a JSON .sldd getter throws mid-extract', () => {
+    // Force an exception inside the try: a text property whose getter throws.
+    // buildGraphSource must catch it and return the empty base node for the URI.
+    const file = {
+      uriString: 'file:///boom.sldd',
+      path: '/boom.sldd',
+    } as RawFile;
+    Object.defineProperty(file, 'text', {
+      get() {
+        throw new Error('boom');
+      },
+      enumerable: true,
+    });
+
+    const s = buildGraphSource(file);
+    expect(s.type).toBe('sldd');
+    expect(s.uriString).toBe('file:///boom.sldd');
+    expect(s.slddRefs).toEqual([]);
+    expect(s.modelRefs).toEqual([]);
+    expect(s.dataDictionary).toBeNull();
+  });
+});