superdoc-dev
diff --git a/‎packages/layout-engine/contracts/src/index.ts‎
Lines changed: 6 additions & 0 deletions b/‎packages/layout-engine/contracts/src/index.ts‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎packages/layout-engine/layout-engine/src/layout-table.ts‎
Lines changed: 13 additions & 5 deletions b/‎packages/layout-engine/layout-engine/src/layout-table.ts‎
Lines changed: 13 additions & 5 deletions
diff --git a/‎packages/layout-engine/layout-engine/src/resolve-table-frame.test.ts‎
Lines changed: 23 additions & 0 deletions b/‎packages/layout-engine/layout-engine/src/resolve-table-frame.test.ts‎
Lines changed: 23 additions & 0 deletions
diff --git a/‎packages/layout-engine/painters/dom/src/table/renderTableFragment.test.ts‎
Lines changed: 34 additions & 0 deletions b/‎packages/layout-engine/painters/dom/src/table/renderTableFragment.test.ts‎
Lines changed: 34 additions & 0 deletions
diff --git a/‎packages/layout-engine/painters/dom/src/table/renderTableFragment.ts‎
Lines changed: 2 additions & 1 deletion b/‎packages/layout-engine/painters/dom/src/table/renderTableFragment.ts‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎packages/layout-engine/pm-adapter/src/attributes/borders.test.ts‎
Lines changed: 129 additions & 0 deletions b/‎packages/layout-engine/pm-adapter/src/attributes/borders.test.ts‎
Lines changed: 129 additions & 0 deletions
@@ -620,10 +620,16 @@ export type TableCellAttrs = {
   tableCellProperties?: Record<string, unknown>;
 };
 
+export type TablePropertiesAttrs = {
+  rightToLeft?: boolean;
+  [key: string]: unknown;
+};
+
 export type TableAttrs = {
   borders?: TableBorders;
   borderCollapse?: 'collapse' | 'separate';
   cellSpacing?: CellSpacing;
+  tableProperties?: TablePropertiesAttrs;
   sdt?: SdtMetadata;
   containerSdt?: SdtMetadata;
   [key: string]: unknown;
 
@@ -181,16 +181,24 @@ export function resolveTableFrame(
   attrs: TableBlock['attrs'],
 ): { x: number; width: number } {
   const width = resolveRenderedTableWidth(columnWidth, tableWidth, attrs);
-  const justification = typeof attrs?.justification === 'string' ? attrs.justification : undefined;
+  const explicitJustification = typeof attrs?.justification === 'string' ? attrs.justification : undefined;
+  const isRtlTable = attrs?.tableProperties?.rightToLeft === true;
+  const effectiveJustification = explicitJustification ?? (isRtlTable ? 'end' : undefined);
+  const tableIndent = getTableIndentWidth(attrs);
 
-  if (justification === 'center') {
+  if (effectiveJustification === 'center') {
     return { x: baseX + (columnWidth - width) / 2, width };
   }
-  if (justification === 'right' || justification === 'end') {
-    return { x: baseX + (columnWidth - width), width };
+  if (effectiveJustification === 'right' || effectiveJustification === 'end') {
+    const rightAlignedX = baseX + (columnWidth - width);
+    // In bidiVisual tables with no explicit jc, Word keeps right alignment
+    // and applies tblInd from the right edge.
+    if (explicitJustification == null && isRtlTable && tableIndent !== 0) {
+      return { x: rightAlignedX - tableIndent, width };
+    }
+    return { x: rightAlignedX, width };
   }
 
-  const tableIndent = getTableIndentWidth(attrs);
   return applyTableIndent(baseX, width, tableIndent, columnWidth);
 }
 
 
@@ -113,6 +113,29 @@ describe('resolveTableFrame', () => {
       const result = resolveTableFrame(0, 500, 600, { justification: 'end' } as TableAttrs);
       expect(result).toEqual({ x: -100, width: 600 });
     });
+
+    it('defaults bidiVisual tables without jc to right alignment', () => {
+      const result = resolveTableFrame(0, 500, 300, {
+        tableProperties: { rightToLeft: true },
+      } as TableAttrs);
+      expect(result).toEqual({ x: 200, width: 300 });
+    });
+
+    it('applies tblInd from the right edge for bidiVisual tables without jc', () => {
+      const result = resolveTableFrame(0, 500, 300, {
+        tableIndent: { width: 40 },
+        tableProperties: { rightToLeft: true },
+      } as TableAttrs);
+      expect(result).toEqual({ x: 160, width: 300 });
+    });
+
+    it('keeps explicit left justification for bidiVisual tables', () => {
+      const result = resolveTableFrame(0, 500, 300, {
+        justification: 'left',
+        tableProperties: { rightToLeft: true },
+      } as TableAttrs);
+      expect(result).toEqual({ x: 0, width: 300 });
+    });
   });
 
   describe('with pct tableWidth', () => {
 
@@ -135,6 +135,40 @@ describe('renderTableFragment', () => {
     expect(element.dataset.pmEnd).toBe('34');
   });
 
+  it('applies outer left/right borders in separate mode even when cellSpacing is unset or zero', () => {
+    const block = createTestTableBlock();
+    block.attrs = {
+      borderCollapse: 'separate',
+      borders: {
+        left: { style: 'single', width: 2, color: '#ff0000' },
+        right: { style: 'single', width: 3, color: '#0000ff' },
+      },
+    };
+
+    const element = renderTableFragment({
+      doc,
+      fragment: createTestTableFragment(),
+      context,
+      block,
+      measure: createTestTableMeasure(),
+      cellSpacingPx: 0,
+      effectiveColumnWidths: [100],
+      renderLine: () => doc.createElement('div'),
+      applyFragmentFrame: () => {
+        // Intentionally empty for test mock
+      },
+      applySdtDataset: () => {
+        // Intentionally empty for test mock
+      },
+      applyStyles: () => {
+        // Intentionally empty for test mock
+      },
+    });
+
+    expect(element.style.borderLeftWidth).toBe('2px');
+    expect(element.style.borderRightWidth).toBe('3px');
+  });
+
   describe('merged-cell border ownership', () => {
     it('renders the outer right border for a merged header cell in collapsed mode', () => {
       const block: TableBlock = {
 
@@ -306,6 +306,7 @@ export const renderTableFragment = (deps: TableRenderDependencies): HTMLElement
         min: boundary.minWidth,
         r: boundary.resizable ? 1 : 0,
       })),
+      rtl: isRtl,
       // Add segments for each column boundary (segments where resize handle should appear)
       segments: boundarySegments.map((segs, colIndex) =>
         segs.map((seg) => ({
@@ -337,7 +338,7 @@ export const renderTableFragment = (deps: TableRenderDependencies): HTMLElement
   }
 
   const borderCollapse = block.attrs?.borderCollapse ?? (block.attrs?.cellSpacing != null ? 'separate' : 'collapse');
-  if (borderCollapse === 'separate' && block.attrs?.cellSpacing && tableBorders) {
+  if (borderCollapse === 'separate' && tableBorders) {
     applyBorder(container, 'Top', borderValueToSpec(tableBorders.top));
     applyBorder(container, 'Right', borderValueToSpec(isRtl ? tableBorders.left : tableBorders.right));
     applyBorder(container, 'Bottom', borderValueToSpec(tableBorders.bottom));
 
@@ -399,6 +399,46 @@ describe('SD-2343 - no double conversion for pre-converted px widths', () => {
     const result = convertBorderSpec({ val: 'single', size: 8 }, { unit: 'eighthPoints' });
     expect(result?.width).toBeCloseTo(1.3333, 4);
   });
+
+  it('maps logical start/end to left/right in LTR when physical sides are missing', () => {
+    const input = {
+      start: { val: 'single', size: 2, color: 'FF0000' },
+      end: { val: 'double', size: 3, color: '0000FF' },
+    };
+
+    const result = extractTableBorders(input, { isRtl: false });
+    expect(result?.left?.style).toBe('single');
+    expect((result?.left as { color?: string })?.color).toBe('#FF0000');
+    expect(result?.right?.style).toBe('double');
+    expect((result?.right as { color?: string })?.color).toBe('#0000FF');
+  });
+
+  it('maps logical start/end as LTR-default regardless of isRtl flag (painter handles RTL mirror)', () => {
+    const input = {
+      start: { val: 'single', size: 2, color: 'FF0000' },
+      end: { val: 'double', size: 3, color: '0000FF' },
+    };
+
+    // Per §17.4.12 + §17.4.33 the visual side flips with table direction,
+    // but the painter's swapTableBordersLR does that mirror once. pm-adapter
+    // pre-swapping would double-mirror, so isRtl is no longer read here.
+    const result = extractTableBorders(input, { isRtl: true });
+    expect(result?.left?.style).toBe('single');
+    expect((result?.left as { color?: string })?.color).toBe('#FF0000');
+    expect(result?.right?.style).toBe('double');
+    expect((result?.right as { color?: string })?.color).toBe('#0000FF');
+  });
+
+  it('keeps explicit physical sides over logical start/end', () => {
+    const input = {
+      left: { val: 'single', size: 1, color: '00AA00' },
+      start: { val: 'double', size: 5, color: 'FF0000' },
+    };
+
+    const result = extractTableBorders(input, { isRtl: false });
+    expect(result?.left?.style).toBe('single');
+    expect((result?.left as { color?: string })?.color).toBe('#00AA00');
+  });
 });
 
 describe('extractCellBorders', () => {
@@ -452,6 +492,47 @@ describe('extractCellBorders', () => {
       expect(result?.top).toBeDefined();
       expect(result?.bottom).toEqual({ style: 'none', width: 0 });
     });
+
+    it('maps start/end to left/right in LTR when physical sides are missing', () => {
+      const input = {
+        borders: {
+          start: { val: 'single', size: 2, color: 'FF0000' },
+          end: { val: 'single', size: 3, color: '0000FF' },
+        },
+      };
+      const result = extractCellBorders(input, { isRtl: false });
+      expect(result?.left).toMatchObject({ style: 'single', width: 2, color: '#FF0000' });
+      expect(result?.right).toMatchObject({ style: 'single', width: 3, color: '#0000FF' });
+    });
+
+    it('maps start/end as LTR-default regardless of isRtl flag (painter handles RTL mirror)', () => {
+      const input = {
+        borders: {
+          start: { val: 'single', size: 2, color: 'FF0000' },
+          end: { val: 'single', size: 3, color: '0000FF' },
+        },
+      };
+      // Per §17.4.12/33, end/start visual side flips with table direction, but
+      // the painter's swapCellBordersLR is the single source of that mirror.
+      // pm-adapter pre-swapping would double-mirror.
+      const result = extractCellBorders(input, { isRtl: true });
+      expect(result?.left).toMatchObject({ style: 'single', width: 2, color: '#FF0000' });
+      expect(result?.right).toMatchObject({ style: 'single', width: 3, color: '#0000FF' });
+    });
+
+    it('keeps explicit physical left/right over logical start/end', () => {
+      const input = {
+        borders: {
+          left: { val: 'single', size: 7, color: '00FF00' },
+          right: { val: 'single', size: 8, color: 'FFFF00' },
+          start: { val: 'single', size: 2, color: 'FF0000' },
+          end: { val: 'single', size: 3, color: '0000FF' },
+        },
+      };
+      const result = extractCellBorders(input, { isRtl: true });
+      expect(result?.left).toMatchObject({ style: 'single', width: 7, color: '#00FF00' });
+      expect(result?.right).toMatchObject({ style: 'single', width: 8, color: '#FFFF00' });
+    });
   });
 
   describe('invalid inputs', () => {
@@ -536,6 +617,54 @@ describe('extractCellPadding', () => {
         left: 12.75,
       });
     });
+
+    it('maps marginStart/marginEnd to left/right in LTR when physical sides are missing', () => {
+      const input = {
+        cellMargins: {
+          marginStart: 11,
+          marginEnd: 22,
+        },
+      };
+      const result = extractCellPadding(input, { isRtl: false });
+      expect(result).toEqual({
+        left: 11,
+        right: 22,
+      });
+    });
+
+    it('maps marginStart/marginEnd as LTR-default regardless of isRtl flag (painter handles RTL mirror)', () => {
+      const input = {
+        cellMargins: {
+          marginStart: 11,
+          marginEnd: 22,
+        },
+      };
+      // renderTableCell.ts mirrors paddingLeft <-> paddingRight when the
+      // table is bidiVisual. pm-adapter must therefore keep marginStart/End
+      // mapped to LTR-default (start->left, end->right) - otherwise the
+      // painter double-mirrors and start padding lands on the visual left.
+      const result = extractCellPadding(input, { isRtl: true });
+      expect(result).toEqual({
+        left: 11,
+        right: 22,
+      });
+    });
+
+    it('keeps explicit physical left/right over logical marginStart/marginEnd', () => {
+      const input = {
+        cellMargins: {
+          left: 33,
+          right: 44,
+          marginStart: 11,
+          marginEnd: 22,
+        },
+      };
+      const result = extractCellPadding(input, { isRtl: true });
+      expect(result).toEqual({
+        left: 33,
+        right: 44,
+      });
+    });
   });
 
   describe('invalid inputs', () => {