@stll/folio-core 0.9.0 → 0.11.0

package/dist/layout-engine/measure/effectiveLineBreakPolicy.d.ts

@@ -0,0 +1,29 @@
+import { ParagraphAttrs, TextRun } from "../types.js";
+import { LineBreakPolicy } from "./lineBreakProvider.js";
+
+//#region src/layout-engine/measure/effectiveLineBreakPolicy.d.ts
+type EffectiveAutomaticHyphenation = Readonly<{
+  type: "disabled";
+}> | Readonly<{
+  type: "enabled";
+  consecutiveLineLimit: number;
+  hyphenationZoneTwips: number;
+}>;
+type EffectiveLineBreakPolicy = Readonly<{
+  /** Exact provider inputs; omitted OOXML values stay omitted for custom providers. */provider: Readonly<LineBreakPolicy>; /** `w:overflowPunct` defaults to enabled when omitted. */
+  hangingPunctuation: boolean; /** Effective document and paragraph automatic-hyphenation state. */
+  automaticHyphenation: EffectiveAutomaticHyphenation;
+}>;
+type ResolveEffectiveLineBreakPolicyOptions = {
+  attrs: ParagraphAttrs | undefined;
+  run: TextRun;
+};
+/** Resolve all authored line-breaking inputs used while measuring one text run. */
+declare const resolveEffectiveLineBreakPolicy: ({
+  attrs,
+  run
+}: ResolveEffectiveLineBreakPolicyOptions) => EffectiveLineBreakPolicy;
+/** Cache fragments for every paragraph attribute consumed by the resolver. */
+declare const lineBreakPolicyCacheParts: (attrs: ParagraphAttrs) => readonly string[];
+//#endregion
+export { lineBreakPolicyCacheParts, resolveEffectiveLineBreakPolicy };

package/dist/layout-engine/measure/effectiveLineBreakPolicy.js

@@ -0,0 +1,60 @@
+import { hasCjk } from "../../utils/scriptSegments.js";
+//#region src/layout-engine/measure/effectiveLineBreakPolicy.ts
+const DEFAULT_HYPHENATION_ZONE_TWIPS = 360;
+/** Resolve all authored line-breaking inputs used while measuring one text run. */
+const resolveEffectiveLineBreakPolicy = ({ attrs, run }) => {
+	const locale = resolveRunLocale(run);
+	const rules = attrs?.lineBreakRules;
+	const before = rules?.noLineBreaksBefore;
+	const after = rules?.noLineBreaksAfter;
+	const automaticHyphenation = attrs?.automaticHyphenation;
+	return {
+		provider: {
+			...locale ? { locale } : {},
+			...attrs?.kinsoku !== void 0 ? { kinsoku: attrs.kinsoku } : {},
+			...before && languageMatches(before.language, locale) ? { noLineBreaksBefore: before.characters } : {},
+			...after && languageMatches(after.language, locale) ? { noLineBreaksAfter: after.characters } : {},
+			...rules?.useLegacyEthiopicAmharicRules ? { useLegacyEthiopicAmharicRules: true } : {},
+			...automaticHyphenation?.doNotHyphenateCaps !== void 0 ? { doNotHyphenateCaps: automaticHyphenation.doNotHyphenateCaps } : {},
+			...run.allCaps === true ? { renderedAllCaps: true } : {}
+		},
+		hangingPunctuation: attrs?.overflowPunctuation !== false,
+		automaticHyphenation: resolveAutomaticHyphenation(attrs)
+	};
+};
+/** Cache fragments for every paragraph attribute consumed by the resolver. */
+const lineBreakPolicyCacheParts = (attrs) => {
+	const parts = [];
+	if (attrs.kinsoku !== void 0) parts.push(`kinsoku:${attrs.kinsoku}`);
+	if (attrs.overflowPunctuation !== void 0) parts.push(`overflow-punct:${attrs.overflowPunctuation}`);
+	if (attrs.suppressAutoHyphens !== void 0) parts.push(`suppress-auto-hyphens:${attrs.suppressAutoHyphens}`);
+	const automaticHyphenation = attrs.automaticHyphenation;
+	if (automaticHyphenation) parts.push(`auto-hyphens:${automaticHyphenation.doNotHyphenateCaps}|${automaticHyphenation.consecutiveLineLimit}|${automaticHyphenation.hyphenationZoneTwips}`);
+	const rules = attrs.lineBreakRules;
+	if (rules) parts.push(`line-break-rules:${rules.noLineBreaksBefore?.language}|${rules.noLineBreaksBefore?.characters}|${rules.noLineBreaksAfter?.language}|${rules.noLineBreaksAfter?.characters}|${rules.useLegacyEthiopicAmharicRules}`);
+	return parts;
+};
+const resolveAutomaticHyphenation = (attrs) => {
+	const automaticHyphenation = attrs?.automaticHyphenation;
+	if (automaticHyphenation?.enabled !== true || attrs?.suppressAutoHyphens === true) return { type: "disabled" };
+	return {
+		type: "enabled",
+		consecutiveLineLimit: automaticHyphenation.consecutiveLineLimit ?? 0,
+		hyphenationZoneTwips: automaticHyphenation.hyphenationZoneTwips ?? DEFAULT_HYPHENATION_ZONE_TWIPS
+	};
+};
+const resolveRunLocale = (run) => {
+	const language = run.language;
+	if (hasCjk(run.text)) return language?.eastAsia ?? language?.val;
+	if (run.rtl) return language?.bidi ?? language?.val;
+	return language?.val;
+};
+const languageMatches = (ruleLanguage, locale) => {
+	if (!ruleLanguage) return true;
+	if (!locale) return false;
+	const rule = ruleLanguage.toLowerCase();
+	const active = locale.toLowerCase();
+	return active === rule || active.startsWith(`${rule}-`) || rule.startsWith(`${active}-`);
+};
+//#endregion
+export { lineBreakPolicyCacheParts, resolveEffectiveLineBreakPolicy };

package/dist/layout-engine/measure/measureParagraph.js

@@ -1,13 +1,14 @@
 import { CJK_FALLBACK_FONT_FAMILY, isCjkFont } from "../../utils/fontResolver.js";
 import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
 import { countCompressibleSpaces } from "./textMeasurementPolicy.js";
-import { buildRunFontStyle, ptToPx } from "./measureHelpers.js";
+import { buildRunFontStyle, ptToPx, twipsToPx } from "./measureHelpers.js";
 import "./lineBreakProvider.js";
 import { calculateTabWidth, pixelsToTwips } from "../../prosemirror/utils/tabCalculator.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
 import { hasCjk } from "../../utils/scriptSegments.js";
 import { measuredLineAdvance } from "../lineFlow.js";
 import { isFloatingImageRun } from "../types.js";
+import { resolveEffectiveLineBreakPolicy } from "./effectiveLineBreakPolicy.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
 import { getFloatingAvailableWidth, getFloatingMargins } from "./floatingZones.js";
 import { getListMarkerInlineWidth } from "./listMarkerWidth.js";
@@ -24,7 +25,7 @@ const DEFAULT_FONT_FAMILY = "Calibri";
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
 const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
-const JUSTIFY_SPACE_CONTRACTION_RATIO = .1;
+const JUSTIFY_SPACE_CONTRACTION_RATIO = .075;
 const JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO = .195;
 const JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO = .23;
 const JUSTIFY_INSET_LIST_SHRINK_TOLERANCE_RATIO = .015;
@@ -51,6 +52,11 @@ function findMaxFittingLength(text, style, maxWidth, forceMin = false, policy) {
 	}
 	return forceMin && best === 0 ? boundaries.at(0) ?? 0 : best;
 }
+function exceedsHyphenationZone(line, zoneTwips) {
+	if (line.width <= 0) return true;
+	const visibleWidth = Math.max(0, line.width - line.trailingWhitespaceWidth);
+	return Math.max(0, line.availableWidth - visibleWidth) > twipsToPx(zoneTwips) + WIDTH_TOLERANCE;
+}
 /**
 * Extract FontStyle from a run that carries RunFormatting (text, tab, or
 * field). All three share the same formatting shape, so they measure the
@@ -60,31 +66,6 @@ function findMaxFittingLength(text, style, maxWidth, forceMin = false, policy) {
 function runToFontStyle(run) {
 	return buildRunFontStyle(run, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE);
 }
-function languageMatches(ruleLanguage, locale) {
-	if (!ruleLanguage) return true;
-	if (!locale) return false;
-	const rule = ruleLanguage.toLowerCase();
-	const active = locale.toLowerCase();
-	return active === rule || active.startsWith(`${rule}-`) || rule.startsWith(`${active}-`);
-}
-function lineBreakPolicy(block, run) {
-	const language = run.language;
-	let locale = language?.val;
-	if (hasCjk(run.text)) locale = language?.eastAsia ?? language?.val;
-	else if (run.rtl) locale = language?.bidi ?? language?.val;
-	const rules = block.attrs?.lineBreakRules;
-	const before = rules?.noLineBreaksBefore;
-	const after = rules?.noLineBreaksAfter;
-	return {
-		...locale ? { locale } : {},
-		...block.attrs?.kinsoku !== void 0 ? { kinsoku: block.attrs.kinsoku } : {},
-		...before && languageMatches(before.language, locale) ? { noLineBreaksBefore: before.characters } : {},
-		...after && languageMatches(after.language, locale) ? { noLineBreaksAfter: after.characters } : {},
-		...rules?.useLegacyEthiopicAmharicRules ? { useLegacyEthiopicAmharicRules: true } : {},
-		...block.attrs?.automaticHyphenation?.doNotHyphenateCaps !== void 0 ? { doNotHyphenateCaps: block.attrs.automaticHyphenation.doNotHyphenateCaps } : {},
-		...run.allCaps === true ? { renderedAllCaps: true } : {}
-	};
-}
 /**
 * Line-HEIGHT style for a text run. Word derives a CJK line's height from an
 * East-Asian face, not the run's ascii font: real documents routinely put CJK
@@ -454,7 +435,10 @@ function computeTrailingGlueWidths(block) {
 		}
 		if (isSpaceOrTab(text.at(0))) continue;
 		const style = runToFontStyle(nextRun);
-		const firstBreak = findWordBreaks(text, lineBreakPolicy(block, nextRun)).at(0);
+		const firstBreak = findWordBreaks(text, resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run: nextRun
+		}).provider).at(0);
 		widths[index] = measureTextWidth(firstBreak === void 0 ? text : trimTrailingSpacesAndTabs(text.slice(0, firstBreak)), style) + (firstBreak === void 0 ? widths[index + 1] ?? 0 : 0);
 	}
 	return widths;
@@ -466,7 +450,10 @@ function computeProtectedCrossRunGlueWidths(block) {
 		if (!run || !isTextRun(run)) continue;
 		const trailing = /(\S+)(\s*)$/u.exec(run.text ?? "");
 		const token = trailing?.[1];
-		const policy = lineBreakPolicy(block, run);
+		const policy = resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run
+		}).provider;
 		if (!token || token.length !== 1 || !policy.locale?.toLocaleLowerCase().startsWith("cs")) continue;
 		let separator = trailing[2] ?? "";
 		let glueWidth = separator.length > 0 ? measureTextWidth(separator, runToFontStyle(run)) : 0;
@@ -512,7 +499,10 @@ function collectCrossRunWord({ block, startRunIndex, startChar }) {
 		if (runIndex !== startRunIndex && isSpaceOrTab(remainder[0])) break;
 		const remainingBudget = 256 - text.length;
 		const boundedRemainder = remainder.slice(0, remainingBudget + 1);
-		const firstBreak = findWordBreaks(boundedRemainder, lineBreakPolicy(block, run)).at(0);
+		const firstBreak = findWordBreaks(boundedRemainder, resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run
+		}).provider).at(0);
 		const segmentText = trimTrailingSpacesAndTabs(firstBreak === void 0 ? boundedRemainder : boundedRemainder.slice(0, firstBreak));
 		if (segmentText.length === 0) break;
 		if (segmentText.length > remainingBudget) return;
@@ -534,7 +524,10 @@ function collectCrossRunWord({ block, startRunIndex, startChar }) {
 	return {
 		text,
 		width,
-		breaks: findHyphenationBreaks(text, lineBreakPolicy(block, firstRun)),
+		breaks: findHyphenationBreaks(text, resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run: firstRun
+		}).provider),
 		segments
 	};
 }
@@ -944,7 +937,11 @@ function measureParagraph(block, maxWidth, options) {
 			const textRun = run;
 			const text = textRun.text;
 			const style = runToFontStyle(textRun);
-			const breakPolicy = lineBreakPolicy(block, textRun);
+			const effectiveLineBreakPolicy = resolveEffectiveLineBreakPolicy({
+				attrs: block.attrs,
+				run: textRun
+			});
+			const breakPolicy = effectiveLineBreakPolicy.provider;
 			const lineHeightStyle = cjkLineHeightStyle(textRun, style);
 			updateMaxFont(lineHeightStyle);
 			if (!text || text.length === 0) {
@@ -966,13 +963,12 @@ function measureParagraph(block, maxWidth, options) {
 				const measuredWord = trimTrailingSpacesAndTabs(word);
 				const wordWidth = measureTextWidth(measuredWord, style);
 				const fullWordWidth = measureTextWidth(word, style);
-				const hangingPunctuationWidth = trailingHangingPunctuationWidth(measuredWord, style, breakPolicy, block.attrs?.overflowPunctuation);
+				const hangingPunctuationWidth = trailingHangingPunctuationWidth(measuredWord, style, breakPolicy, effectiveLineBreakPolicy.hangingPunctuation);
 				const isFirstLine = lines.length === 0;
 				const regularSpaceWidth = compressibleSpaceWidth(measuredWord, style);
 				const widthTolerance = isJustifiedParagraph ? justifyFitTolerance(currentLine, isFirstLine ? firstLineJustifyFitStrategy : continuationJustifyFitStrategy, regularSpaceWidth) : WIDTH_TOLERANCE;
-				const automaticHyphenation = block.attrs?.automaticHyphenation;
-				const consecutiveLineLimit = automaticHyphenation?.consecutiveLineLimit ?? 0;
-				const mayHyphenateLine = automaticHyphenation?.enabled === true && block.attrs?.suppressAutoHyphens !== true && (consecutiveLineLimit === 0 || consecutiveHyphenatedLines < consecutiveLineLimit);
+				const automaticHyphenation = effectiveLineBreakPolicy.automaticHyphenation;
+				const mayHyphenateLine = automaticHyphenation.type === "enabled" && (automaticHyphenation.consecutiveLineLimit === 0 || consecutiveHyphenatedLines < automaticHyphenation.consecutiveLineLimit) && exceedsHyphenationZone(currentLine, automaticHyphenation.hyphenationZoneTwips);
 				const isRunTail = nextBreak === text.length;
 				const crossRunWord = mayHyphenateLine && isRunTail && word.length > 0 && !isBreakChar(word.at(-1)) ? collectCrossRunWord({
 					block,

package/dist/layout-engine/measure/tableCellFloating.js

@@ -3,6 +3,36 @@ import { isFloatingImageRun } from "../types.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
 import { createTableCellFlowState, placeTableCellBlock } from "./tableCellFlow.js";
 //#region src/layout-engine/measure/tableCellFloating.ts
+const resolveCellScopedPosition = ({ run, paragraphY, contentWidth }) => {
+	const position = run.position;
+	let side = "left";
+	let x = 0;
+	if (position?.horizontal) {
+		const horizontal = position.horizontal;
+		if (horizontal.align === "right") {
+			side = "right";
+			x = contentWidth - run.width;
+		} else if (horizontal.align === "center") x = (contentWidth - run.width) / 2;
+		else if (horizontal.posOffset !== void 0) {
+			x = emuToPixels(horizontal.posOffset);
+			side = x > contentWidth / 2 ? "right" : "left";
+		}
+	} else if (run.cssFloat === "right") {
+		side = "right";
+		x = contentWidth - run.width;
+	}
+	let y = paragraphY;
+	if (position?.vertical) {
+		const vertical = position.vertical;
+		if (vertical.posOffset !== void 0) y = paragraphY + emuToPixels(vertical.posOffset);
+		else if (vertical.align === "top") y = 0;
+	}
+	return {
+		side,
+		x,
+		y
+	};
+};
 function getTableCellContentWidth(cell, cellMeasure) {
 	const padLeft = cell?.padding?.left ?? 7;
 	const padRight = cell?.padding?.right ?? 7;
@@ -19,40 +49,16 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth, resolvePosi
 		if (block.kind !== "paragraph") continue;
 		for (const run of block.runs) {
 			if (run.kind !== "image" || !isFloatingImageRun(run)) continue;
-			const position = run.position;
 			const distTop = run.distTop ?? 0;
 			const distBottom = run.distBottom ?? 0;
 			const distLeft = run.distLeft ?? 12;
 			const distRight = run.distRight ?? 12;
-			let side;
-			let x;
-			let y;
-			if (resolvePosition) ({side, x, y} = resolvePosition(run, placement.contentTop));
-			else {
-				side = "left";
-				x = 0;
-				if (position?.horizontal) {
-					const horizontal = position.horizontal;
-					if (horizontal.align === "right") {
-						side = "right";
-						x = contentWidth - run.width;
-					} else if (horizontal.align === "center") x = (contentWidth - run.width) / 2;
-					else if (horizontal.posOffset !== void 0) {
-						x = emuToPixels(horizontal.posOffset);
-						side = x > contentWidth / 2 ? "right" : "left";
-					}
-				} else if (run.cssFloat === "right") {
-					side = "right";
-					x = contentWidth - run.width;
-				}
-				y = placement.contentTop;
-				if (position?.vertical) {
-					const vertical = position.vertical;
-					if (vertical.posOffset !== void 0) y = placement.contentTop + emuToPixels(vertical.posOffset);
-					else if (vertical.align === "top") y = 0;
-				}
-				x = Math.max(0, Math.min(x, contentWidth - run.width));
-			}
+			const verticalOriginY = run.position?.vertical?.relativeTo === "paragraph" ? placement.top : placement.contentTop;
+			const resolved = run.layoutInCell === false && resolvePosition ? resolvePosition(run, verticalOriginY) : resolveCellScopedPosition({
+				run,
+				paragraphY: verticalOriginY,
+				contentWidth
+			});
 			let wrapText = "bothSides";
 			if (run.cssFloat === "left") wrapText = "right";
 			else if (run.cssFloat === "right") wrapText = "left";
@@ -67,9 +73,9 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth, resolvePosi
 				...run.cropRight != null ? { cropRight: run.cropRight } : {},
 				...run.cropBottom != null ? { cropBottom: run.cropBottom } : {},
 				...run.cropLeft != null ? { cropLeft: run.cropLeft } : {},
-				x,
-				y,
-				side,
+				x: resolved.x,
+				y: resolved.y,
+				side: resolved.side,
 				distTop,
 				distBottom,
 				distLeft,

package/dist/layout-engine/types.d.ts

@@ -162,7 +162,8 @@ type ImageRun = {
    * eigenpal #424 (opacity render pipeline).
    */
   opacity?: number; /** Position for floating/anchored images */
-  position?: ImageRunPosition; /** Wrap type from DOCX (inline, square, tight, through, topAndBottom, etc.) */
+  position?: ImageRunPosition; /** Whether a table-cell anchor uses the cell as its positioning scope. Undefined defaults true. */
+  layoutInCell?: boolean; /** Wrap type from DOCX (inline, square, tight, through, topAndBottom, etc.) */
   wrapType?: ImageWrap["type"]; /** Display mode for CSS rendering */
   displayMode?: "inline" | "block" | "float"; /** CSS float direction */
   cssFloat?: "left" | "right" | "none"; /** Wrap distances in pixels */
@@ -293,13 +294,14 @@ type ListNumPr = {
  */
 type ParagraphAttrs = {
   alignment?: "left" | "center" | "right" | "justify"; /** East Asian first/last-character restrictions (`w:kinsoku`). */
-  kinsoku?: boolean; /** Hanging punctuation (`w:overflowPunct`), retained for layout policy. */
+  kinsoku?: boolean; /** Hanging punctuation (`w:overflowPunct`); defaults to enabled when omitted. */
   overflowPunctuation?: boolean; /** Exempt this paragraph from document automatic hyphenation. */
   suppressAutoHyphens?: boolean; /** Document-wide automatic hyphenation controls retained for line layout. */
   automaticHyphenation?: {
     enabled: true;
     doNotHyphenateCaps?: boolean;
-    consecutiveLineLimit?: number;
+    consecutiveLineLimit?: number; /** Maximum tolerated line-end whitespace before hyphenation, in twips. */
+    hyphenationZoneTwips?: number;
   }; /** Document-wide custom line-edge characters and compatibility behavior. */
   lineBreakRules?: {
     noLineBreaksBefore?: {

package/dist/managers/FindReplaceManager.d.ts

@@ -37,6 +37,14 @@ declare class FindReplaceManager<TMatch extends FindMatchPosition> {
     match: TMatch;
     index: number;
   } | null;
+  /**
+   * Move the cursor to an explicit match index. Returns the selected match, or
+   * null when there is no active result or the index is out of bounds.
+   */
+  goTo(index: number): {
+    match: TMatch;
+    index: number;
+  } | null;
   /**
    * Replace the current match's text. Returns the new document, or null when
    * there is no current match or the replace fails.

package/dist/managers/FindReplaceManager.js

@@ -61,6 +61,24 @@ var FindReplaceManager = class {
 		} : null;
 	}
 	/**
+	* Move the cursor to an explicit match index. Returns the selected match, or
+	* null when there is no active result or the index is out of bounds.
+	*/
+	goTo(index) {
+		const result = this.result;
+		if (!result || index < 0 || index >= result.matches.length) return null;
+		const match = result.matches.at(index);
+		if (!match) return null;
+		this.result = {
+			...result,
+			currentIndex: index
+		};
+		return {
+			match,
+			index
+		};
+	}
+	/**
 	* Replace the current match's text. Returns the new document, or null when
 	* there is no current match or the replace fails.
 	*/

package/dist/managers/TableSelectionManager.d.ts

@@ -52,6 +52,12 @@ type TableActionResult = {
 };
 declare class TableSelectionManager extends Subscribable<TableSelectionState> {
   constructor();
+  /**
+   * Track cell coordinates before a document model is available. This supports
+   * adapter pointer state without fabricating a table context; callers that
+   * need structural operations should use {@link selectCell} with a document.
+   */
+  selectCellCoordinates(coords: CellCoordinates): void;
   /**
    * Select a cell within `doc`. Resolves the table at `coords.tableIndex` and
    * derives the full {@link TableContext}. Returns the context, or `null` (and

package/dist/managers/TableSelectionManager.js

@@ -107,6 +107,20 @@ var TableSelectionManager = class extends Subscribable {
 		super(EMPTY_SELECTION);
 	}
 	/**
+	* Track cell coordinates before a document model is available. This supports
+	* adapter pointer state without fabricating a table context; callers that
+	* need structural operations should use {@link selectCell} with a document.
+	*/
+	selectCellCoordinates(coords) {
+		this.setSnapshot({
+			context: null,
+			table: null,
+			tableIndex: coords.tableIndex,
+			rowIndex: coords.rowIndex,
+			columnIndex: coords.columnIndex
+		});
+	}
+	/**
 	* Select a cell within `doc`. Resolves the table at `coords.tableIndex` and
 	* derives the full {@link TableContext}. Returns the context, or `null` (and
 	* clears the selection) when that table no longer exists.

package/dist/prosemirror/attrs/index.js

@@ -306,6 +306,7 @@ const readImageAttrs = (node) => {
 	optionalNumber(attrs, "distLeft", "image.attrs.distLeft", issues);
 	optionalNumber(attrs, "distRight", "image.attrs.distRight", issues);
 	optionalImagePosition(attrs, "position", "image.attrs.position", issues);
+	optionalBoolean(attrs, "layoutInCell", "image.attrs.layoutInCell", issues);
 	optionalNumber(attrs, "borderWidth", "image.attrs.borderWidth", issues);
 	optionalString(attrs, "borderColor", "image.attrs.borderColor", issues);
 	optionalString(attrs, "borderStyle", "image.attrs.borderStyle", issues);

package/dist/prosemirror/conversion/effectiveTableCellFormatting.d.ts

@@ -0,0 +1,62 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/prosemirror/conversion/effectiveTableCellFormatting.d.ts
+type TableCellMarginsAttrs = {
+  top?: number;
+  bottom?: number;
+  left?: number;
+  right?: number;
+};
+type EffectiveTableCellWidth = {
+  type: "none";
+} | {
+  type: "value";
+  source: "direct" | "grid";
+  value: number;
+  widthType: document_d_exports.TableWidthType;
+};
+type EffectiveTableCellBackground = {
+  type: "none";
+  source: "none" | "direct" | "style";
+} | {
+  type: "color";
+  source: "direct" | "style";
+  rgb: string;
+};
+type EffectiveTableCellFormatting = Readonly<{
+  width: EffectiveTableCellWidth;
+  background: EffectiveTableCellBackground;
+  borders: document_d_exports.TableCellBorders | undefined;
+  margins: TableCellMarginsAttrs | undefined;
+}>;
+type TableCellPosition = {
+  isFirstRow?: boolean;
+  isLastRow?: boolean;
+  isFirstColumn?: boolean;
+  isLastColumn?: boolean;
+};
+type ResolveEffectiveTableCellFormattingOptions = {
+  directFormatting: document_d_exports.TableCellFormatting | undefined;
+  styleFormatting: document_d_exports.TableCellFormatting | undefined;
+  tableBorders: document_d_exports.TableBorders | undefined;
+  position: TableCellPosition;
+  gridWidthPercent: number | undefined;
+  defaultMargins: TableCellMarginsAttrs | undefined;
+  theme: document_d_exports.Theme | null | undefined;
+};
+/**
+ * Resolve the display-facing table-cell cascade without mutating authored
+ * OOXML formatting. Source discriminators keep inherited values distinct from
+ * direct values that the editor may later override.
+ */
+declare const resolveEffectiveTableCellFormatting: ({
+  directFormatting,
+  styleFormatting,
+  tableBorders,
+  position,
+  gridWidthPercent,
+  defaultMargins,
+  theme
+}: ResolveEffectiveTableCellFormattingOptions) => EffectiveTableCellFormatting;
+//#endregion
+export { TableCellMarginsAttrs, TableCellPosition, resolveEffectiveTableCellFormatting };

package/dist/prosemirror/conversion/effectiveTableCellFormatting.js

@@ -0,0 +1,131 @@
+import { resolveColor } from "../../utils/colorResolver.js";
+import { resolveShadingFill } from "../../utils/formatToStyle.js";
+//#region src/prosemirror/conversion/effectiveTableCellFormatting.ts
+const TABLE_BORDER_SIDES = [
+	"top",
+	"bottom",
+	"left",
+	"right",
+	"insideH",
+	"insideV",
+	"topLeftToBottomRight",
+	"topRightToBottomLeft"
+];
+/**
+* Resolve the display-facing table-cell cascade without mutating authored
+* OOXML formatting. Source discriminators keep inherited values distinct from
+* direct values that the editor may later override.
+*/
+const resolveEffectiveTableCellFormatting = ({ directFormatting, styleFormatting, tableBorders, position, gridWidthPercent, defaultMargins, theme }) => {
+	return {
+		width: resolveEffectiveWidth(directFormatting, gridWidthPercent),
+		background: resolveEffectiveBackground({
+			directFormatting,
+			styleFormatting,
+			theme
+		}),
+		borders: resolveEffectiveBorders({
+			directFormatting,
+			styleFormatting,
+			tableBorders,
+			position,
+			theme
+		}),
+		margins: resolveEffectiveMargins({
+			directFormatting,
+			styleFormatting,
+			defaultMargins
+		})
+	};
+};
+const resolveEffectiveWidth = (directFormatting, gridWidthPercent) => {
+	const directWidth = directFormatting?.width;
+	if (directWidth) return {
+		type: "value",
+		source: "direct",
+		value: directWidth.value,
+		widthType: directWidth.type
+	};
+	if (gridWidthPercent !== void 0) return {
+		type: "value",
+		source: "grid",
+		value: gridWidthPercent,
+		widthType: "pct"
+	};
+	return { type: "none" };
+};
+const resolveEffectiveBackground = ({ directFormatting, styleFormatting, theme }) => {
+	const directShading = directFormatting?.shading;
+	if (directShading !== void 0) return resolveBackgroundColor({
+		shading: directShading,
+		source: "direct",
+		theme
+	});
+	const styleShading = styleFormatting?.shading;
+	if (styleShading !== void 0) return resolveBackgroundColor({
+		shading: styleShading,
+		source: "style",
+		theme
+	});
+	return {
+		type: "none",
+		source: "none"
+	};
+};
+const resolveBackgroundColor = ({ shading, source, theme }) => {
+	const rgb = resolveShadingFill(shading, theme).replace(/^#/u, "");
+	if (!rgb) return {
+		type: "none",
+		source
+	};
+	return {
+		type: "color",
+		source,
+		rgb
+	};
+};
+const resolveEffectiveBorders = ({ directFormatting, styleFormatting, tableBorders, position, theme }) => {
+	const baseBorders = tableBorders ? {
+		top: position.isFirstRow ? tableBorders.top : tableBorders.insideH,
+		bottom: position.isLastRow ? tableBorders.bottom : tableBorders.insideH,
+		left: position.isFirstColumn ? tableBorders.left : tableBorders.insideV,
+		right: position.isLastColumn ? tableBorders.right : tableBorders.insideV
+	} : void 0;
+	const styleBorders = styleFormatting?.borders;
+	const directBorders = directFormatting?.borders;
+	const borders = baseBorders || styleBorders || directBorders ? {
+		...baseBorders,
+		...styleBorders,
+		...directBorders
+	} : void 0;
+	return resolveThemedBorderColors(borders, theme);
+};
+const resolveEffectiveMargins = ({ directFormatting, styleFormatting, defaultMargins }) => {
+	if (directFormatting?.margins) return cellMarginsToAttrs(directFormatting.margins);
+	if (styleFormatting?.margins) return cellMarginsToAttrs(styleFormatting.margins);
+	return defaultMargins;
+};
+const cellMarginsToAttrs = (margins) => {
+	const result = {};
+	if (margins.top?.value !== void 0) result.top = margins.top.value;
+	if (margins.bottom?.value !== void 0) result.bottom = margins.bottom.value;
+	if (margins.left?.value !== void 0) result.left = margins.left.value;
+	if (margins.right?.value !== void 0) result.right = margins.right.value;
+	return result;
+};
+const resolveThemedBorderColors = (borders, theme) => {
+	if (!borders || !theme?.colorScheme) return borders;
+	let resolved;
+	for (const side of TABLE_BORDER_SIDES) {
+		const border = borders[side];
+		if (!border?.color?.themeColor || border.color.auto) continue;
+		resolved ??= { ...borders };
+		resolved[side] = {
+			...border,
+			color: { rgb: resolveColor(border.color, theme).replace(/^#/u, "") }
+		};
+	}
+	return resolved ?? borders;
+};
+//#endregion
+export { resolveEffectiveTableCellFormatting };

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -911,6 +911,7 @@ function createImageRun(node) {
 	if (attrs.opacity != null) image.opacity = attrs.opacity;
 	const imagePosition = imagePositionFromAttrs(attrs.position);
 	if (imagePosition) image.position = imagePosition;
+	if (attrs.layoutInCell !== void 0) image.layoutInCell = attrs.layoutInCell;
 	if (attrs.borderWidth && attrs.borderWidth > 0) {
 		const outline = {
 			width: pixelsToEmu(attrs.borderWidth),