@stll/folio-core 0.16.0 → 0.17.1

package/dist/layout-painter/cursiveJoiners.d.ts

@@ -0,0 +1,80 @@
+//#region src/layout-painter/cursiveJoiners.d.ts
+/**
+ * Repair cursive letter connections that a face change severed.
+ *
+ * Browsers shape across an inline box boundary only while no shaping-relevant
+ * property changes. Colour and underline are safe, so tracked-change and
+ * comment marks already join. A face change is not: bold, italic, a different
+ * size or a different family selects another font, shaping stops there, and a
+ * cursive word split mid-word by such a run falls back to isolated forms and
+ * visibly comes apart. Word joins straight through the same boundary.
+ *
+ * The repair is a zero-width joiner on each side of the boundary, carried in its
+ * OWN span rather than appended to the run's text. That distinction is
+ * load-bearing: `data-pm-start`/`data-pm-end` spans map DOM text offsets back to
+ * ProseMirror positions for hit-testing, so growing a run's text node by a
+ * character would desync every offset after it. A joiner span carries no pm
+ * attributes, so the offset contract is untouched.
+ *
+ * Whether two runs share a face is decided by running the painter's own
+ * `applyRunStyles` over a probe element for each side and diffing the result,
+ * rather than by re-deriving the face from run fields. There is no second copy
+ * of the font decisions to drift from the first, and a property this module has
+ * never heard of counts as a face change: over-inserting a joiner is invisible,
+ * missing one is not.
+ *
+ * KNOWN RESIDUAL — the measurer does not see this repair. Canvas `measureText`
+ * ignores a joiner at a string edge (measuring the two halves with and without
+ * one returns bit-identical widths), while DOM layout applies the joined forms.
+ * So a repaired word paints at a different width than the measurer reserved, by
+ * roughly the difference between isolated and medial advances.
+ *
+ * Which DIRECTION depends on the font: measured against two Arabic fallback
+ * faces the divergence was -2.7px on one and +2.5px on the other. So it is a
+ * bounded disagreement that can push a line either way, NOT a safe
+ * over-reservation, and a line can therefore come out marginally too long. It
+ * arises only on words that contain a face change, and
+ * `tests/visual/measure-parity.spec.ts` holds it to a budget. Closing it needs widths from a real shaper
+ * rather than canvas; until then the trade is a correct rendering against a
+ * slightly wrong measurement, which beats a measurement that exactly matches a
+ * visibly broken rendering.
+ */
+/** Marks a span as joiner furniture: no text of its own, no pm positions. */
+declare const JOINER_DATASET_KEY = "docxJoiner";
+/** `applyRunStyles`, injected so this module does not import the painter back. */
+type ApplyRunStyles<TRun> = (element: HTMLElement, run: TRun) => void;
+/** Which side(s) of a run need a joiner span. */
+type JoinerSides = {
+  leading: boolean;
+  trailing: boolean;
+};
+type PlanOptions<TRun> = {
+  /** Runs in paint order, already sliced for the line and script-split. */
+  runs: readonly TRun[];
+  /** Text of a run, or undefined for a run that paints no text (image, break). */
+  textOf: (run: TRun) => string | undefined;
+  applyRunStyles: ApplyRunStyles<TRun>;
+  doc: Document;
+};
+/**
+ * Decide, for each run, whether it needs a joiner on either side.
+ *
+ * Only adjacent text-bearing runs are considered: an image or a tab between two
+ * words means they were never connected, so no joiner belongs there.
+ */
+declare function planCursiveJoiners<TRun>({ runs, textOf, applyRunStyles, doc }: PlanOptions<TRun>): Map<TRun, JoinerSides>;
+/**
+ * Build a joiner span wearing `run`'s own painted styles, so shaping crosses
+ * from that run into the joiner and takes the joined form.
+ *
+ * Without the matching styles the joiner would sit in a different face and the
+ * repair would be a no-op that still looked applied.
+ */
+declare function createJoinerSpan<TRun>(run: TRun, applyRunStyles: ApplyRunStyles<TRun>, doc: Document): HTMLElement;
+/**
+ * A run element wrapped with whatever joiners its boundaries need, ready to
+ * spread into `append`. Returns the element alone when no repair applies.
+ */
+declare function withCursiveJoiners<TRun>(runEl: HTMLElement, run: TRun, plan: Map<TRun, JoinerSides>, applyRunStyles: ApplyRunStyles<TRun>, doc: Document): HTMLElement[];
+//#endregion
+export { ApplyRunStyles, JOINER_DATASET_KEY, JoinerSides, createJoinerSpan, planCursiveJoiners, withCursiveJoiners };

package/dist/layout-painter/cursiveJoiners.js

@@ -0,0 +1,199 @@
+import { hasCursiveLetter, joinsAcrossBoundary } from "../utils/cursiveJoining.js";
+//#region src/layout-painter/cursiveJoiners.ts
+/**
+* Repair cursive letter connections that a face change severed.
+*
+* Browsers shape across an inline box boundary only while no shaping-relevant
+* property changes. Colour and underline are safe, so tracked-change and
+* comment marks already join. A face change is not: bold, italic, a different
+* size or a different family selects another font, shaping stops there, and a
+* cursive word split mid-word by such a run falls back to isolated forms and
+* visibly comes apart. Word joins straight through the same boundary.
+*
+* The repair is a zero-width joiner on each side of the boundary, carried in its
+* OWN span rather than appended to the run's text. That distinction is
+* load-bearing: `data-pm-start`/`data-pm-end` spans map DOM text offsets back to
+* ProseMirror positions for hit-testing, so growing a run's text node by a
+* character would desync every offset after it. A joiner span carries no pm
+* attributes, so the offset contract is untouched.
+*
+* Whether two runs share a face is decided by running the painter's own
+* `applyRunStyles` over a probe element for each side and diffing the result,
+* rather than by re-deriving the face from run fields. There is no second copy
+* of the font decisions to drift from the first, and a property this module has
+* never heard of counts as a face change: over-inserting a joiner is invisible,
+* missing one is not.
+*
+* KNOWN RESIDUAL — the measurer does not see this repair. Canvas `measureText`
+* ignores a joiner at a string edge (measuring the two halves with and without
+* one returns bit-identical widths), while DOM layout applies the joined forms.
+* So a repaired word paints at a different width than the measurer reserved, by
+* roughly the difference between isolated and medial advances.
+*
+* Which DIRECTION depends on the font: measured against two Arabic fallback
+* faces the divergence was -2.7px on one and +2.5px on the other. So it is a
+* bounded disagreement that can push a line either way, NOT a safe
+* over-reservation, and a line can therefore come out marginally too long. It
+* arises only on words that contain a face change, and
+* `tests/visual/measure-parity.spec.ts` holds it to a budget. Closing it needs widths from a real shaper
+* rather than canvas; until then the trade is a correct rendering against a
+* slightly wrong measurement, which beats a measurement that exactly matches a
+* visibly broken rendering.
+*/
+/** U+200D ZERO WIDTH JOINER — Joining_Type C, so it joins on both sides. */
+const ZERO_WIDTH_JOINER = "‍";
+/** Marks a span as joiner furniture: no text of its own, no pm positions. */
+const JOINER_DATASET_KEY = "docxJoiner";
+/**
+* Inline properties that `applyRunStyles` may set which provably cannot change
+* how text shapes, and so must NOT be read as a face change.
+*
+* A deny-list rather than an allow-list on purpose: an unlisted new property is
+* treated as face-changing, which inserts a harmless extra joiner instead of
+* silently stopping the repair. Fails toward the visible-correct rendering.
+*/
+const SHAPING_NEUTRAL_STYLE_PROPERTIES = /* @__PURE__ */ new Set([
+	"color",
+	"--doc-run-color",
+	"backgroundColor",
+	"background-color",
+	"textDecoration",
+	"text-decoration",
+	"textDecorationColor",
+	"text-decoration-color",
+	"textDecorationStyle",
+	"text-decoration-style",
+	"textUnderlineOffset",
+	"text-underline-offset",
+	"verticalAlign",
+	"vertical-align",
+	"opacity",
+	"borderBottom",
+	"border-bottom",
+	"outline"
+]);
+/**
+* The style declaration a run paints with, as a plain comparable record.
+*
+* Reading the keys the painter actually assigned (rather than enumerating a
+* CSSStyleDeclaration) keeps this working against both the real DOM and the
+* minimal fake the painter tests use.
+*/
+function paintedStyle(run, applyRunStyles, doc) {
+	const probe = doc.createElement("span");
+	applyRunStyles(probe, run);
+	const style = {};
+	for (const [property, value] of styleEntries(probe.style)) {
+		if (value === "") continue;
+		if (SHAPING_NEUTRAL_STYLE_PROPERTIES.has(property)) continue;
+		style[property] = value;
+	}
+	return style;
+}
+/**
+* Enumerate the properties a declaration actually has set.
+*
+* A real `CSSStyleDeclaration` is not a plain object: `Object.entries` on one
+* yields its INDEXED entries, so `["0", "font-family"]` rather than
+* `["fontFamily", "Arial"]`, which compares the list of property names instead
+* of their values. The painter's test fake IS a plain object. Both shapes have
+* to work, and the difference between them is invisible in unit tests, so it is
+* handled here explicitly rather than left to whichever one a caller happens to
+* pass. Real declarations report kebab-case names, including custom properties.
+*/
+function styleEntries(style) {
+	const declaration = style;
+	if (typeof declaration.length === "number" && typeof declaration.item === "function" && typeof declaration.getPropertyValue === "function") {
+		const entries = [];
+		for (let index = 0; index < declaration.length; index++) {
+			const property = declaration.item(index);
+			entries.push([property, declaration.getPropertyValue(property)]);
+		}
+		return entries;
+	}
+	return Object.entries(style).filter((entry) => typeof entry[1] === "string");
+}
+const sameFace = (a, b) => {
+	const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+	for (const key of keys) if (a[key] !== b[key]) return false;
+	return true;
+};
+/**
+* Decide, for each run, whether it needs a joiner on either side.
+*
+* Only adjacent text-bearing runs are considered: an image or a tab between two
+* words means they were never connected, so no joiner belongs there.
+*/
+function planCursiveJoiners({ runs, textOf, applyRunStyles, doc }) {
+	const plan = /* @__PURE__ */ new Map();
+	if (runs.length < 2) return plan;
+	let lineHasCursive = false;
+	for (const run of runs) {
+		const text = textOf(run);
+		if (text !== void 0 && hasCursiveLetter(text)) {
+			lineHasCursive = true;
+			break;
+		}
+	}
+	if (!lineHasCursive) return plan;
+	const styleCache = /* @__PURE__ */ new Map();
+	const styleOf = (run) => {
+		const cached = styleCache.get(run);
+		if (cached) return cached;
+		const computed = paintedStyle(run, applyRunStyles, doc);
+		styleCache.set(run, computed);
+		return computed;
+	};
+	const mark = (run, side) => {
+		const existing = plan.get(run);
+		if (existing) {
+			existing[side] = true;
+			return;
+		}
+		plan.set(run, {
+			leading: side === "leading",
+			trailing: side === "trailing"
+		});
+	};
+	for (let i = 0; i < runs.length - 1; i++) {
+		const before = runs[i];
+		const after = runs[i + 1];
+		const beforeText = textOf(before);
+		const afterText = textOf(after);
+		if (beforeText === void 0 || afterText === void 0) continue;
+		if (!joinsAcrossBoundary(beforeText, afterText)) continue;
+		if (sameFace(styleOf(before), styleOf(after))) continue;
+		mark(before, "trailing");
+		mark(after, "leading");
+	}
+	return plan;
+}
+/**
+* Build a joiner span wearing `run`'s own painted styles, so shaping crosses
+* from that run into the joiner and takes the joined form.
+*
+* Without the matching styles the joiner would sit in a different face and the
+* repair would be a no-op that still looked applied.
+*/
+function createJoinerSpan(run, applyRunStyles, doc) {
+	const span = doc.createElement("span");
+	applyRunStyles(span, run);
+	span.dataset[JOINER_DATASET_KEY] = "true";
+	span.textContent = ZERO_WIDTH_JOINER;
+	return span;
+}
+/**
+* A run element wrapped with whatever joiners its boundaries need, ready to
+* spread into `append`. Returns the element alone when no repair applies.
+*/
+function withCursiveJoiners(runEl, run, plan, applyRunStyles, doc) {
+	const sides = plan.get(run);
+	if (!sides) return [runEl];
+	const elements = [];
+	if (sides.leading) elements.push(createJoinerSpan(run, applyRunStyles, doc));
+	elements.push(runEl);
+	if (sides.trailing) elements.push(createJoinerSpan(run, applyRunStyles, doc));
+	return elements;
+}
+//#endregion
+export { JOINER_DATASET_KEY, createJoinerSpan, planCursiveJoiners, withCursiveJoiners };

package/dist/layout-painter/renderPage.js

@@ -1323,6 +1323,7 @@ function runContentKey(run) {
 	if (run.color) parts.push(`c:${run.color}`);
 	if (run.highlight) parts.push(`hi:${run.highlight}`);
 	if (run.fontFamily) parts.push(`ff:${run.fontFamily}`);
+	if (run.complexScriptFontFamily) parts.push(`cs:${run.complexScriptFontFamily}`);
 	if (run.eastAsiaFontFamily) parts.push(`ea:${run.eastAsiaFontFamily}`);
 	if (run.fontSize !== void 0) parts.push(`fs:${run.fontSize}`);
 	if (run.letterSpacing !== void 0) parts.push(`ls:${run.letterSpacing}`);

package/dist/layout-painter/renderParagraph.js

@@ -12,8 +12,9 @@ import { resolveFontFamily } from "../utils/fontResolver.js";
 import "../utils/fontWeights.js";
 import { inlineImageBoundingBox, parseRotationDegrees, rotatedBoundingBox } from "../utils/rotationBoundingBox.js";
 import { applySanitizedImageSrc } from "../utils/sanitizeImageSrc.js";
-import { hasCjk, segmentByScript } from "../utils/scriptSegments.js";
+import { SCRIPT_CLASS, hasCjk, hasComplexScript, segmentByScript } from "../utils/scriptSegments.js";
 import { borderStrokeToCss, resolveParagraphBorderHorizontalOutsets } from "./borderStroke.js";
+import { planCursiveJoiners, withCursiveJoiners } from "./cursiveJoiners.js";
 import { getAutomaticTextColorForBackground } from "./documentColors.js";
 import { applyImageBorder, applyImageVisualAttrs, hasImageCrop, hasImageVisualAttrs, wrapImageWithCrop } from "./renderImage.js";
 import { resolveImageLineAlign } from "./renderUtils.js";
@@ -591,7 +592,10 @@ function renderFieldRun(run, doc, context) {
 		kind: "text",
 		text
 	};
-	if (resolvedRun.eastAsiaFontFamily !== void 0 && !resolvedRun.letterSpacing && hasCjk(text)) {
+	if (needsPerScriptSpans({
+		...resolvedRun,
+		text
+	})) {
 		const wrapper = doc.createElement("span");
 		applyPmPositions(wrapper, resolvedRun.pmStart, resolvedRun.pmEnd);
 		if (resolvedRun.horizontalScale && resolvedRun.horizontalScale !== 100) {
@@ -604,7 +608,7 @@ function renderFieldRun(run, doc, context) {
 			const segmentRun = {
 				...segmentBase,
 				text: segment.text,
-				...segment.isCjk ? { fontFamily: resolvedRun.eastAsiaFontFamily } : {}
+				...scriptFontOverride(resolvedRun, segment.script)
 			};
 			wrapper.append(renderTextRun(segmentRun, doc));
 		}
@@ -719,6 +723,26 @@ function sliceRunsForLine(block, line) {
 	return result;
 }
 /**
+* The font a script segment paints with, mirroring the measurer's
+* `scriptFontFamily`. Returning undefined leaves the run's own `fontFamily`.
+*/
+const scriptFontOverride = (run, script) => {
+	if (script === SCRIPT_CLASS.eastAsia && run.eastAsiaFontFamily !== void 0) return { fontFamily: run.eastAsiaFontFamily };
+	if (script === SCRIPT_CLASS.complex && run.complexScriptFontFamily !== void 0) return { fontFamily: run.complexScriptFontFamily };
+	return {};
+};
+/**
+* Whether a run needs per-script sibling spans: it carries a script-specific
+* font slot AND text that selects it. A letter-spaced run is excluded because
+* CSS letter-spacing does not bridge sibling spans, and the measurer skips the
+* same case so the widths still agree.
+*/
+const needsPerScriptSpans = (run) => {
+	if (run.letterSpacing) return false;
+	if (run.eastAsiaFontFamily !== void 0 && hasCjk(run.text)) return true;
+	return run.complexScriptFontFamily !== void 0 && hasComplexScript(run.text);
+};
+/**
 * Split each text run carrying an East-Asian font into per-script sub-runs, so
 * CJK code points render with `eastAsiaFontFamily` and the rest with
 * `fontFamily`. Each sub-run gets a contiguous, exact `pmStart`/`pmEnd` (the
@@ -730,7 +754,7 @@ function sliceRunsForLine(block, line) {
 function splitTextRunsByEastAsia(runs) {
 	const result = [];
 	for (const run of runs) {
-		if (!isTextRun(run) || run.eastAsiaFontFamily === void 0 || run.letterSpacing || !hasCjk(run.text)) {
+		if (!isTextRun(run) || !needsPerScriptSpans(run)) {
 			result.push(run);
 			continue;
 		}
@@ -739,7 +763,7 @@ function splitTextRunsByEastAsia(runs) {
 			result.push({
 				...run,
 				text: segment.text,
-				...segment.isCjk ? { fontFamily: run.eastAsiaFontFamily } : {},
+				...scriptFontOverride(run, segment.script),
 				...run.pmStart !== void 0 ? {
 					pmStart: run.pmStart + offset,
 					pmEnd: run.pmStart + offset + segment.text.length
@@ -842,6 +866,7 @@ function runMeasureStyle(run) {
 		...run.letterSpacing !== void 0 ? { letterSpacing: run.letterSpacing } : {},
 		...run.smallCaps !== void 0 ? { smallCaps: run.smallCaps } : {},
 		...run.eastAsiaFontFamily !== void 0 ? { eastAsiaFontFamily: run.eastAsiaFontFamily } : {},
+		...run.complexScriptFontFamily !== void 0 ? { complexScriptFontFamily: run.complexScriptFontFamily } : {},
 		kerning: getRunFontKerningMode(run, 11) === FONT_KERNING_MODE.enabled
 	};
 }
@@ -956,11 +981,14 @@ function createTextMeasurer(doc) {
 		if (style.bold) fontPrefixParts.push("700");
 		fontPrefixParts.push(`${fontSizePx}px`);
 		const fontPrefix = fontPrefixParts.join(" ");
-		if (style.eastAsiaFontFamily && !style.letterSpacing && hasCjk(text)) {
-			const eaFallback = resolveFontFamily(style.eastAsiaFontFamily).cssFallback;
+		const perScriptFallback = {
+			...style.eastAsiaFontFamily ? { [SCRIPT_CLASS.eastAsia]: resolveFontFamily(style.eastAsiaFontFamily).cssFallback } : {},
+			...style.complexScriptFontFamily ? { [SCRIPT_CLASS.complex]: resolveFontFamily(style.complexScriptFontFamily).cssFallback } : {}
+		};
+		if (!style.letterSpacing && (style.eastAsiaFontFamily && hasCjk(text) || style.complexScriptFontFamily && hasComplexScript(text))) {
 			let segmentedWidth = 0;
 			for (const segment of segmentByScript(text)) {
-				ctx.font = `${fontPrefix} ${segment.isCjk ? eaFallback : cssFallback}`;
+				ctx.font = `${fontPrefix} ${perScriptFallback[segment.script] ?? cssFallback}`;
 				segmentedWidth += ctx.measureText(segment.text).width;
 			}
 			return segmentedWidth;
@@ -985,10 +1013,24 @@ function renderLine(block, line, alignment, doc, options) {
 	lineEl.style.boxSizing = "content-box";
 	lineEl.style.height = `${line.lineHeight}px`;
 	lineEl.style.lineHeight = `${line.lineHeight}px`;
+	lineEl.dataset["measuredWidth"] = String(line.width);
 	const splitRuns = splitTextRunsByEastAsia(sliceRunsForLine(block, line));
 	const { runs: runsForLine, collapsedLeadingRuns: collapsedLeadingSpaceRuns, collapsedTrailingRuns: collapsedTrailingSpaceRuns } = splitCollapsibleLineEdgeSpaces(splitRuns, startsAfterSoftWrap(block, line));
 	const isCollapsedLineEdgeSpaceRun = (run) => collapsedLeadingSpaceRuns.has(run) || collapsedTrailingSpaceRuns.has(run);
 	const collapsedSpaceMeasureText = collapsedLeadingSpaceRuns.size > 0 || collapsedTrailingSpaceRuns.size > 0 ? createTextMeasurer(doc) : void 0;
+	const applyJoinerRunStyles = (element, run) => {
+		if (isTextRun(run) || isTabRun(run)) applyRunStyles(element, run);
+	};
+	const cursiveJoinerPlan = planCursiveJoiners({
+		runs: runsForLine,
+		textOf: (run) => isTextRun(run) ? toPaintedText(run.text) : void 0,
+		applyRunStyles: applyJoinerRunStyles,
+		doc
+	});
+	const withJoiners = (runEl, run) => {
+		if (lineEl.style.display === "flex") return [runEl];
+		return withCursiveJoiners(runEl, run, cursiveJoinerPlan, applyJoinerRunStyles, doc);
+	};
 	const renderLineTextRun = (run) => {
 		const runEl = renderTextRun(run, doc);
 		if (collapsedLeadingSpaceRuns.has(run)) runEl.dataset["collapsedLeadingSpaces"] = "true";
@@ -1032,10 +1074,11 @@ function renderLine(block, line, alignment, doc, options) {
 	if (alignment === "justify" && options) {
 		if (!options.isLastLine || options.paragraphEndsWithLineBreak) {
 			const firstLineIndentPx = options.isFirstLine ? options.firstLineIndentPx ?? 0 : 0;
+			const firstLinePositiveIndentPx = Math.max(0, firstLineIndentPx);
 			const firstLineHangingPx = Math.max(0, -firstLineIndentPx);
 			const hasVisibleListMarker = options.isFirstLine && block.attrs?.listMarker && !block.attrs.listMarkerHidden;
 			const firstLineHangingExpansionPx = hasVisibleListMarker ? Math.min(firstLineHangingPx, Math.max(0, options.leftIndentPx ?? 0)) : firstLineHangingPx;
-			const justifyCapacityPx = options.availableWidth + firstLineHangingExpansionPx;
+			const justifyCapacityPx = options.availableWidth - firstLinePositiveIndentPx + firstLineHangingExpansionPx;
 			const overfullPx = line.width - justifyCapacityPx;
 			const shrinkableSpaces = countShrinkableSpaces(runsForLine.filter((run) => !isTextRun(run) || !isCollapsedLineEdgeSpaceRun(run)), options.context);
 			if (overfullPx > RIGHT_EDGE_EPSILON_PX && shrinkableSpaces > 0) {
@@ -1113,7 +1156,7 @@ function renderLine(block, line, alignment, doc, options) {
 				for (let j = i + 1; j < runsForLine.length; j++) {
 					const next = runsForLine[j];
 					if (isTabRun(next) || isLineBreakRun(next)) break;
-					if (isTextRun(next)) lineEl.append(renderLineTextRun(next));
+					if (isTextRun(next)) lineEl.append(...withJoiners(renderLineTextRun(next), next));
 					else if (isFieldRun(next) && options?.context) lineEl.append(renderFieldRun(next, doc, options.context));
 					else if (isImageRun(next)) {
 						if (isFloatingImageRun(next)) continue;
@@ -1133,7 +1176,7 @@ function renderLine(block, line, alignment, doc, options) {
 			currentX += tabWidth;
 		} else if (isTextRun(run)) {
 			const runEl = renderLineTextRun(run);
-			lineEl.append(runEl);
+			lineEl.append(...withJoiners(runEl, run));
 			if (isCollapsedLineEdgeSpaceRun(run)) continue;
 			if (!measureText) continue;
 			const fontSize = run.fontSize || 11;

package/dist/server.d.ts

@@ -18,8 +18,8 @@ import { EvaluateDocxXmlPatchProposalArgs, FOLIO_DOCX_XML_PATCH_PROPOSAL_DEFAULT
 import { FOLIO_DOCX_CONFORMANCE_CHECKS, FOLIO_DOCX_CONFORMANCE_ISSUE_CODES, FOLIO_DOCX_CONFORMANCE_PROFILE, FOLIO_DOCX_CONFORMANCE_REPORT_VERSION, FolioDocxConformanceCheck, FolioDocxConformanceCheckId, FolioDocxConformanceCheckStatus, FolioDocxConformanceIssue, FolioDocxConformanceIssueCode, FolioDocxConformanceReport, FolioDocxConformanceStatus, ValidateDocxConformanceOptions, validateDocxConformance } from "./docx/server/validateDocxConformance.js";
 import { ApplyDocxXmlPatchProposalArgs, FOLIO_DOCX_XML_PATCH_APPLICATION_PROFILE, FOLIO_DOCX_XML_PATCH_APPLICATION_VERSION, FolioDocxXmlPatchApplication, FolioDocxXmlPatchApplicationError, FolioDocxXmlPatchApplicationReceipt, UnsupportedFolioDocxXmlPatchApplicationProfileError, applyDocxXmlPatchProposal } from "./docx/server/applyDocxXmlPatchProposal.js";
 import { docxToMarkdown } from "./docx/server/docxToMarkdown.js";
-import { DocxParagraphSource, DocxTableRowKind, DocxTableRowPosition, ExtractedDocxParagraph, ExtractedDocxText, extractDocxText } from "./docx/server/extractDocxText.js";
+import { DocxParagraphSource, DocxTableRowKind, DocxTableRowPosition, ExtractedDocxParagraph, ExtractedDocxTableCell, ExtractedDocxTableCellParagraph, ExtractedDocxText, extractDocxText } from "./docx/server/extractDocxText.js";
 import { FOLIO_DOCX_PACKAGE_INSPECTION_DEFAULTS, FOLIO_DOCX_PACKAGE_INSPECTION_ERROR_CODES, FOLIO_DOCX_PACKAGE_INSPECTION_VERSION, FolioDocxInspectedXmlPart, FolioDocxPackageInspection, FolioDocxPackageInspectionError, FolioDocxPackageInspectionErrorCode, FolioDocxPackageInspectionLimits, FolioDocxPackagePart, FolioDocxPackagePartKind, InspectDocxPackageOptions, inspectDocxPackage } from "./docx/server/inspectDocxPackage.js";
 import { GenerateRedlineDocxOptions, GenerateRedlineDocxResult, GenerateRedlineUnprocessedStory, InvalidGenerateRedlineDocxOptionsError, generateRedlineDocx } from "./redline.js";
 import { FOLIO_VERSION_COMPARISON_PRIVACY_TRANSFORMS, FOLIO_VERSION_COMPARISON_SCOPES, FolioBlockDiff, FolioCompareDocxVersionsOptions, FolioDocumentMetadataValue, FolioFormatProperty, FolioMetadataDiff, FolioStoryDiff, FolioVersionBlockHandle, FolioVersionComparisonPrivacyTransform, FolioVersionComparisonScope, FolioVersionDiff, FolioVersionDiffPrivacyOptions, FolioVersionDiffPrivacyReport, FolioVersionDiffSegment, FolioVersionDiffSummaryCounts, InvalidFolioVersionComparisonOptionsError, applyFolioVersionDiffPrivacy, compareDocxVersions, isFolioVersionComparisonPrivacyTransform, isFolioVersionComparisonScope } from "./version-comparison.js";
-export { type ApplyDocxXmlPatchProposalArgs, type ApplyFolioAIEditsToBufferOptions, type ApplyFolioAIEditsToBufferResult, type CreateCommentReplyInput, type CreateEmptyDocumentOptions, DOCUMENT_PRESET_VERSION, DOCUMENT_STYLE_SET_VERSION, type DeriveBlockIdInput, type DocumentPreset, type DocumentStyleCatalog, type DocumentStyleCatalogEntry, type DocumentStyleSet, DocxArchiveError, type DocxArchiveOptions, type DocxParagraphSource, type DocxTableRowKind, type DocxTableRowPosition, EnsureParaIdsError, type EnsureParaIdsOptions, type EnsureParaIdsResult, type EvaluateDocxXmlPatchProposalArgs, type ExtractDocumentStyleSetOptions, type ExtractedDocxParagraph, type ExtractedDocxText, FOLIO_DOCUMENT_METADATA_PROPERTIES, FOLIO_DOCUMENT_OPERATION_BATCH_MODES, FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION, FOLIO_DOCUMENT_OPERATION_MODES, FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE, FOLIO_DOCUMENT_OPERATION_PRECONDITIONS, FOLIO_DOCUMENT_OPERATION_STORIES, FOLIO_DOCUMENT_OPERATION_TYPES, FOLIO_DOCUMENT_PRIVACY_TRANSFORMS, FOLIO_DOCX_CONFORMANCE_CHECKS, FOLIO_DOCX_CONFORMANCE_ISSUE_CODES, FOLIO_DOCX_CONFORMANCE_PROFILE, FOLIO_DOCX_CONFORMANCE_REPORT_VERSION, FOLIO_DOCX_PACKAGE_INSPECTION_DEFAULTS, FOLIO_DOCX_PACKAGE_INSPECTION_ERROR_CODES, FOLIO_DOCX_PACKAGE_INSPECTION_VERSION, FOLIO_DOCX_XML_PATCH_APPLICATION_PROFILE, FOLIO_DOCX_XML_PATCH_APPLICATION_VERSION, FOLIO_DOCX_XML_PATCH_PROPOSAL_DEFAULTS, FOLIO_DOCX_XML_PATCH_PROPOSAL_ISSUE_CODES, FOLIO_DOCX_XML_PATCH_PROPOSAL_PROFILE, FOLIO_DOCX_XML_PATCH_PROPOSAL_VERSION, FOLIO_RESOLVED_REVIEWED_VIEWS, FOLIO_REVIEWED_VIEWS, FOLIO_VERSION_COMPARISON_PRIVACY_TRANSFORMS, FOLIO_VERSION_COMPARISON_SCOPES, type FolioAIBlock, type FolioAIBlockAnchor, type FolioAIBlockKind, type FolioAIBlockPreviewRun, type FolioAIComment, type FolioAIEditApplyMode, type FolioAIEditApplyResult, type FolioAIEditOperation, type FolioAIEditPrecondition, type FolioAIEditSnapshot, type FolioAIInlineFormatting, type FolioAITextRangeHandle, type FolioApplyDocumentOperationsOptions, type FolioApplyDocumentOperationsToStoryOptions, type FolioApplyOperationsOptions, type FolioBlockDiff, type FolioBlockId, type FolioCompareDocxVersionsOptions, type FolioDocumentMetadataProperty, type FolioDocumentMetadataValue, type FolioDocumentNavigationTarget, type FolioDocumentOperation, type FolioDocumentOperationAffectedTarget, type FolioDocumentOperationBatch, type FolioDocumentOperationCapabilities, type FolioDocumentOperationIssue, type FolioDocumentOperationMode, type FolioDocumentOperationPrecondition, type FolioDocumentOperationReceipt, type FolioDocumentOperationRecovery, type FolioDocumentOperationResult, type FolioDocumentOperationStatus, type FolioDocumentOperationStory, type FolioDocumentOperationType, type FolioDocumentOperationUndoFailureReason, type FolioDocumentOperationUndoHandle, type FolioDocumentOperationUndoResult, type FolioDocumentOutline, type FolioDocumentOutlineEntry, FolioDocumentPrivacyArchiveError, type FolioDocumentPrivacyOptions, type FolioDocumentPrivacyReport, type FolioDocumentPrivacyTransform, type FolioDocumentSection, type FolioDocumentSectionHandle, type FolioDocumentSectionReadResult, type FolioDocumentStory, type FolioDocumentStoryHandle, FolioDocumentStoryNotFoundError, type FolioDocxConformanceCheck, type FolioDocxConformanceCheckId, type FolioDocxConformanceCheckStatus, type FolioDocxConformanceIssue, type FolioDocxConformanceIssueCode, type FolioDocxConformanceReport, type FolioDocxConformanceStatus, type FolioDocxInspectedXmlPart, type FolioDocxPackageInspection, FolioDocxPackageInspectionError, type FolioDocxPackageInspectionErrorCode, type FolioDocxPackageInspectionLimits, type FolioDocxPackagePart, type FolioDocxPackagePartKind, type FolioDocxPreparedXmlReplacement, FolioDocxReviewer, type FolioDocxReviewerOptions, type FolioDocxXmlPatchApplication, FolioDocxXmlPatchApplicationError, type FolioDocxXmlPatchApplicationReceipt, type FolioDocxXmlPatchProposal, type FolioDocxXmlPatchProposalEvaluation, type FolioDocxXmlPatchProposalIssue, type FolioDocxXmlPatchProposalIssueCode, type FolioDocxXmlPatchProposalLimits, type FolioDocxXmlReplacement, type FolioEditableDocumentStoryHandle, type FolioFormatProperty, type FolioMetadataDiff, type FolioReadReviewedStoryOptions, type FolioResolveReviewedStoryOptions, type FolioResolvedReviewedView, type FolioReviewChange, type FolioReviewChangeFilter, type FolioReviewChangeKind, type FolioReviewComment, type FolioReviewCommentFilter, type FolioReviewCommentReply, type FolioReviewReplyInput, type FolioReviewedStory, type FolioReviewedView, type FolioStoryDiff, type FolioVersionBlockHandle, type FolioVersionComparisonPrivacyTransform, type FolioVersionComparisonScope, type FolioVersionDiff, type FolioVersionDiffPrivacyOptions, type FolioVersionDiffPrivacyReport, type FolioVersionDiffSegment, type FolioVersionDiffSummaryCounts, type GenerateRedlineDocxOptions, type GenerateRedlineDocxResult, type GenerateRedlineUnprocessedStory, type InspectDocxPackageOptions, InvalidFolioDocumentOperationBatchError, InvalidFolioDocumentPrivacyOptionsError, InvalidFolioDocxXmlPatchProposalError, InvalidFolioDocxXmlPatchProposalOptionsError, InvalidFolioVersionComparisonOptionsError, InvalidGenerateRedlineDocxOptionsError, type RewriteDocxMetadataPrivacyResult, STELLA_STYLE_SET_NAME, UnsupportedFolioDocumentOperationVersionError, UnsupportedFolioDocxXmlPatchApplicationProfileError, UnsupportedFolioReviewedViewError, type ValidateDocxConformanceOptions, applyDocxXmlPatchProposal, applyFolioAIEditsToBuffer, applyFolioVersionDiffPrivacy, assertSupportedFolioDocumentOperationVersion, compareDocxVersions, createDocx, createEmptyDocument, createFolioAITextRangeHandle, createStellaStyleDocumentPreset, createStellaStyleSet, deriveBlockId, docxToMarkdown, ensureParaIds, evaluateDocxXmlPatchProposal, extractDocumentStyleSet, extractDocumentStyleSetFromDocx, extractDocxText, generateRedlineDocx, getFolioDocumentOperationCapabilities, getFolioDocumentOperationIssues, getFolioDocumentOperationReceipts, getFolioDocumentOutline, getFolioParaIdFromBlockId, hashFolioAIBlockText, inspectDocumentStyles, inspectDocumentStylesFromDocx, inspectDocxPackage, isFolioBlockId, isFolioDocumentOperationModeSupported, isFolioDocumentPrivacyTransform, isFolioResolvedReviewedView, isFolioReviewedView, isFolioVersionComparisonPrivacyTransform, isFolioVersionComparisonScope, isSequentialFolioBlockId, isSupportedFolioDocumentOperationVersion, normalizeFolioAIBlockText, parseFolioDocumentOperationBatch, parseFolioDocxXmlPatchProposal, readFolioDocumentSection, replyToComment, rewriteDocxMetadataPrivacy, validateDocxConformance };
+export { type ApplyDocxXmlPatchProposalArgs, type ApplyFolioAIEditsToBufferOptions, type ApplyFolioAIEditsToBufferResult, type CreateCommentReplyInput, type CreateEmptyDocumentOptions, DOCUMENT_PRESET_VERSION, DOCUMENT_STYLE_SET_VERSION, type DeriveBlockIdInput, type DocumentPreset, type DocumentStyleCatalog, type DocumentStyleCatalogEntry, type DocumentStyleSet, DocxArchiveError, type DocxArchiveOptions, type DocxParagraphSource, type DocxTableRowKind, type DocxTableRowPosition, EnsureParaIdsError, type EnsureParaIdsOptions, type EnsureParaIdsResult, type EvaluateDocxXmlPatchProposalArgs, type ExtractDocumentStyleSetOptions, type ExtractedDocxParagraph, type ExtractedDocxTableCell, type ExtractedDocxTableCellParagraph, type ExtractedDocxText, FOLIO_DOCUMENT_METADATA_PROPERTIES, FOLIO_DOCUMENT_OPERATION_BATCH_MODES, FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION, FOLIO_DOCUMENT_OPERATION_MODES, FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE, FOLIO_DOCUMENT_OPERATION_PRECONDITIONS, FOLIO_DOCUMENT_OPERATION_STORIES, FOLIO_DOCUMENT_OPERATION_TYPES, FOLIO_DOCUMENT_PRIVACY_TRANSFORMS, FOLIO_DOCX_CONFORMANCE_CHECKS, FOLIO_DOCX_CONFORMANCE_ISSUE_CODES, FOLIO_DOCX_CONFORMANCE_PROFILE, FOLIO_DOCX_CONFORMANCE_REPORT_VERSION, FOLIO_DOCX_PACKAGE_INSPECTION_DEFAULTS, FOLIO_DOCX_PACKAGE_INSPECTION_ERROR_CODES, FOLIO_DOCX_PACKAGE_INSPECTION_VERSION, FOLIO_DOCX_XML_PATCH_APPLICATION_PROFILE, FOLIO_DOCX_XML_PATCH_APPLICATION_VERSION, FOLIO_DOCX_XML_PATCH_PROPOSAL_DEFAULTS, FOLIO_DOCX_XML_PATCH_PROPOSAL_ISSUE_CODES, FOLIO_DOCX_XML_PATCH_PROPOSAL_PROFILE, FOLIO_DOCX_XML_PATCH_PROPOSAL_VERSION, FOLIO_RESOLVED_REVIEWED_VIEWS, FOLIO_REVIEWED_VIEWS, FOLIO_VERSION_COMPARISON_PRIVACY_TRANSFORMS, FOLIO_VERSION_COMPARISON_SCOPES, type FolioAIBlock, type FolioAIBlockAnchor, type FolioAIBlockKind, type FolioAIBlockPreviewRun, type FolioAIComment, type FolioAIEditApplyMode, type FolioAIEditApplyResult, type FolioAIEditOperation, type FolioAIEditPrecondition, type FolioAIEditSnapshot, type FolioAIInlineFormatting, type FolioAITextRangeHandle, type FolioApplyDocumentOperationsOptions, type FolioApplyDocumentOperationsToStoryOptions, type FolioApplyOperationsOptions, type FolioBlockDiff, type FolioBlockId, type FolioCompareDocxVersionsOptions, type FolioDocumentMetadataProperty, type FolioDocumentMetadataValue, type FolioDocumentNavigationTarget, type FolioDocumentOperation, type FolioDocumentOperationAffectedTarget, type FolioDocumentOperationBatch, type FolioDocumentOperationCapabilities, type FolioDocumentOperationIssue, type FolioDocumentOperationMode, type FolioDocumentOperationPrecondition, type FolioDocumentOperationReceipt, type FolioDocumentOperationRecovery, type FolioDocumentOperationResult, type FolioDocumentOperationStatus, type FolioDocumentOperationStory, type FolioDocumentOperationType, type FolioDocumentOperationUndoFailureReason, type FolioDocumentOperationUndoHandle, type FolioDocumentOperationUndoResult, type FolioDocumentOutline, type FolioDocumentOutlineEntry, FolioDocumentPrivacyArchiveError, type FolioDocumentPrivacyOptions, type FolioDocumentPrivacyReport, type FolioDocumentPrivacyTransform, type FolioDocumentSection, type FolioDocumentSectionHandle, type FolioDocumentSectionReadResult, type FolioDocumentStory, type FolioDocumentStoryHandle, FolioDocumentStoryNotFoundError, type FolioDocxConformanceCheck, type FolioDocxConformanceCheckId, type FolioDocxConformanceCheckStatus, type FolioDocxConformanceIssue, type FolioDocxConformanceIssueCode, type FolioDocxConformanceReport, type FolioDocxConformanceStatus, type FolioDocxInspectedXmlPart, type FolioDocxPackageInspection, FolioDocxPackageInspectionError, type FolioDocxPackageInspectionErrorCode, type FolioDocxPackageInspectionLimits, type FolioDocxPackagePart, type FolioDocxPackagePartKind, type FolioDocxPreparedXmlReplacement, FolioDocxReviewer, type FolioDocxReviewerOptions, type FolioDocxXmlPatchApplication, FolioDocxXmlPatchApplicationError, type FolioDocxXmlPatchApplicationReceipt, type FolioDocxXmlPatchProposal, type FolioDocxXmlPatchProposalEvaluation, type FolioDocxXmlPatchProposalIssue, type FolioDocxXmlPatchProposalIssueCode, type FolioDocxXmlPatchProposalLimits, type FolioDocxXmlReplacement, type FolioEditableDocumentStoryHandle, type FolioFormatProperty, type FolioMetadataDiff, type FolioReadReviewedStoryOptions, type FolioResolveReviewedStoryOptions, type FolioResolvedReviewedView, type FolioReviewChange, type FolioReviewChangeFilter, type FolioReviewChangeKind, type FolioReviewComment, type FolioReviewCommentFilter, type FolioReviewCommentReply, type FolioReviewReplyInput, type FolioReviewedStory, type FolioReviewedView, type FolioStoryDiff, type FolioVersionBlockHandle, type FolioVersionComparisonPrivacyTransform, type FolioVersionComparisonScope, type FolioVersionDiff, type FolioVersionDiffPrivacyOptions, type FolioVersionDiffPrivacyReport, type FolioVersionDiffSegment, type FolioVersionDiffSummaryCounts, type GenerateRedlineDocxOptions, type GenerateRedlineDocxResult, type GenerateRedlineUnprocessedStory, type InspectDocxPackageOptions, InvalidFolioDocumentOperationBatchError, InvalidFolioDocumentPrivacyOptionsError, InvalidFolioDocxXmlPatchProposalError, InvalidFolioDocxXmlPatchProposalOptionsError, InvalidFolioVersionComparisonOptionsError, InvalidGenerateRedlineDocxOptionsError, type RewriteDocxMetadataPrivacyResult, STELLA_STYLE_SET_NAME, UnsupportedFolioDocumentOperationVersionError, UnsupportedFolioDocxXmlPatchApplicationProfileError, UnsupportedFolioReviewedViewError, type ValidateDocxConformanceOptions, applyDocxXmlPatchProposal, applyFolioAIEditsToBuffer, applyFolioVersionDiffPrivacy, assertSupportedFolioDocumentOperationVersion, compareDocxVersions, createDocx, createEmptyDocument, createFolioAITextRangeHandle, createStellaStyleDocumentPreset, createStellaStyleSet, deriveBlockId, docxToMarkdown, ensureParaIds, evaluateDocxXmlPatchProposal, extractDocumentStyleSet, extractDocumentStyleSetFromDocx, extractDocxText, generateRedlineDocx, getFolioDocumentOperationCapabilities, getFolioDocumentOperationIssues, getFolioDocumentOperationReceipts, getFolioDocumentOutline, getFolioParaIdFromBlockId, hashFolioAIBlockText, inspectDocumentStyles, inspectDocumentStylesFromDocx, inspectDocxPackage, isFolioBlockId, isFolioDocumentOperationModeSupported, isFolioDocumentPrivacyTransform, isFolioResolvedReviewedView, isFolioReviewedView, isFolioVersionComparisonPrivacyTransform, isFolioVersionComparisonScope, isSequentialFolioBlockId, isSupportedFolioDocumentOperationVersion, normalizeFolioAIBlockText, parseFolioDocumentOperationBatch, parseFolioDocxXmlPatchProposal, readFolioDocumentSection, replyToComment, rewriteDocxMetadataPrivacy, validateDocxConformance };

package/dist/utils/cursiveJoining.d.ts

@@ -0,0 +1,49 @@
+//#region src/utils/cursiveJoining.d.ts
+/**
+ * Cursive-joining queries for scripts whose letters change shape by position.
+ *
+ * In Arabic, Syriac, N'Ko, Adlam and friends a letter's glyph depends on its
+ * neighbours: isolated, initial, medial or final. Shaping stops at an element
+ * boundary whenever the two sides resolve to a different font face, so a run
+ * split inside a word — bold on one letter, a different size, a different
+ * family — makes the word come apart visually, while Word joins straight
+ * through it. These predicates say whether a given split severed a connection,
+ * so the painter and the measurer can repair it identically.
+ *
+ * A boundary where both sides share a face is NOT a problem: browsers shape
+ * across inline boxes when no shaping-relevant property changes, so ordinary
+ * colour or underline marks (tracked changes, comment anchors) already join.
+ *
+ * The tables come from the pinned UCD via `scripts/generate-joining-types.ts`;
+ * see {@link joiningTypes.gen} for why they are generated rather than authored.
+ */
+/** Joining_Type D, L or C: this code point can connect to the one after it. */
+declare const joinsToFollowing: (cp: number) => boolean;
+/** Joining_Type D, R or C: this code point can connect to the one before it. */
+declare const joinsToPreceding: (cp: number) => boolean;
+/**
+ * Joining_Type T: invisible to joining. Combining marks (harakat, Syriac
+ * vowels) sit between two letters without breaking their connection, so they
+ * must be skipped when looking for a joining neighbour.
+ */
+declare const isJoiningTransparent: (cp: number) => boolean;
+/** Joining_Type D, L or R: a cursive letter, as opposed to ZWJ or punctuation. */
+declare const isCursiveLetter: (cp: number) => boolean;
+/**
+ * Whether the text contains any cursive letter at all.
+ *
+ * Callers gate on this so the all-Latin hot path never pays for joining
+ * analysis, mirroring how `hasCjk` gates script segmentation.
+ */
+declare function hasCursiveLetter(text: string): boolean;
+/**
+ * Whether `before` and `after` were cursively connected before something split
+ * them apart.
+ *
+ * True means the two sides need a joiner to keep rendering as one word. False
+ * means the split is harmless: a space, a non-joining letter such as alef on
+ * the left of the cut, punctuation, or a script that does not join at all.
+ */
+declare function joinsAcrossBoundary(before: string, after: string): boolean;
+//#endregion
+export { hasCursiveLetter, isCursiveLetter, isJoiningTransparent, joinsAcrossBoundary, joinsToFollowing, joinsToPreceding };

package/dist/utils/cursiveJoining.js

@@ -0,0 +1,97 @@
+import { JOINING_LETTER_RANGES, JOINING_TRANSPARENT_RANGES, JOINS_BACKWARD_RANGES, JOINS_FORWARD_RANGES } from "./joiningTypes.gen.js";
+//#region src/utils/cursiveJoining.ts
+/**
+* Cursive-joining queries for scripts whose letters change shape by position.
+*
+* In Arabic, Syriac, N'Ko, Adlam and friends a letter's glyph depends on its
+* neighbours: isolated, initial, medial or final. Shaping stops at an element
+* boundary whenever the two sides resolve to a different font face, so a run
+* split inside a word — bold on one letter, a different size, a different
+* family — makes the word come apart visually, while Word joins straight
+* through it. These predicates say whether a given split severed a connection,
+* so the painter and the measurer can repair it identically.
+*
+* A boundary where both sides share a face is NOT a problem: browsers shape
+* across inline boxes when no shaping-relevant property changes, so ordinary
+* colour or underline marks (tracked changes, comment anchors) already join.
+*
+* The tables come from the pinned UCD via `scripts/generate-joining-types.ts`;
+* see {@link joiningTypes.gen} for why they are generated rather than authored.
+*/
+/**
+* Membership test over a flat sorted `[start, end, …]` inclusive-range list.
+*
+* Binary search rather than `.some()`: the transparent table alone is 375
+* ranges, and these run per code point on every measured word.
+*/
+function inRanges(ranges, cp) {
+	let low = 0;
+	let high = ranges.length / 2 - 1;
+	while (low <= high) {
+		const mid = low + high >> 1;
+		const start = ranges[mid * 2];
+		const end = ranges[mid * 2 + 1];
+		if (cp < start) high = mid - 1;
+		else if (cp > end) low = mid + 1;
+		else return true;
+	}
+	return false;
+}
+/** Joining_Type D, L or C: this code point can connect to the one after it. */
+const joinsToFollowing = (cp) => inRanges(JOINS_FORWARD_RANGES, cp);
+/** Joining_Type D, R or C: this code point can connect to the one before it. */
+const joinsToPreceding = (cp) => inRanges(JOINS_BACKWARD_RANGES, cp);
+/**
+* Joining_Type T: invisible to joining. Combining marks (harakat, Syriac
+* vowels) sit between two letters without breaking their connection, so they
+* must be skipped when looking for a joining neighbour.
+*/
+const isJoiningTransparent = (cp) => inRanges(JOINING_TRANSPARENT_RANGES, cp);
+/** Joining_Type D, L or R: a cursive letter, as opposed to ZWJ or punctuation. */
+const isCursiveLetter = (cp) => inRanges(JOINING_LETTER_RANGES, cp);
+/**
+* Whether the text contains any cursive letter at all.
+*
+* Callers gate on this so the all-Latin hot path never pays for joining
+* analysis, mirroring how `hasCjk` gates script segmentation.
+*/
+function hasCursiveLetter(text) {
+	for (const ch of text) if (isCursiveLetter(ch.codePointAt(0))) return true;
+	return false;
+}
+/** Last code point of `text` that joining can see, skipping transparents. */
+function lastJoiningRelevantCodePoint(text) {
+	let index = text.length;
+	while (index > 0) {
+		const unit = text.charCodeAt(index - 1);
+		const isLowSurrogate = unit >= 56320 && unit <= 57343;
+		const high = isLowSurrogate ? text.charCodeAt(index - 2) : NaN;
+		const start = isLowSurrogate && high >= 55296 && high <= 56319 ? index - 2 : index - 1;
+		const cp = text.codePointAt(start);
+		if (!isJoiningTransparent(cp)) return cp;
+		index = start;
+	}
+}
+/** First code point of `text` that joining can see, skipping transparents. */
+function firstJoiningRelevantCodePoint(text) {
+	for (const ch of text) {
+		const cp = ch.codePointAt(0);
+		if (!isJoiningTransparent(cp)) return cp;
+	}
+}
+/**
+* Whether `before` and `after` were cursively connected before something split
+* them apart.
+*
+* True means the two sides need a joiner to keep rendering as one word. False
+* means the split is harmless: a space, a non-joining letter such as alef on
+* the left of the cut, punctuation, or a script that does not join at all.
+*/
+function joinsAcrossBoundary(before, after) {
+	const previous = lastJoiningRelevantCodePoint(before);
+	if (previous === void 0 || !joinsToFollowing(previous)) return false;
+	const next = firstJoiningRelevantCodePoint(after);
+	return next !== void 0 && joinsToPreceding(next);
+}
+//#endregion
+export { hasCursiveLetter, isCursiveLetter, isJoiningTransparent, joinsAcrossBoundary, joinsToFollowing, joinsToPreceding };

package/dist/utils/joiningTypes.gen.d.ts

@@ -0,0 +1,26 @@
+//#region src/utils/joiningTypes.gen.d.ts
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * Unicode Joining_Type ranges, derived from the pinned UCD sources by
+ * `scripts/generate-joining-types.ts`. Regenerate with:
+ *
+ *   bun run generate:joining-types
+ *
+ * ArabicShaping.txt: 17.0.0
+ * DerivedGeneralCategory.txt: 17.0.0
+ *
+ * Each table is a flat sorted `[start, end, …]` list of inclusive code-point
+ * ranges. Transparent is dominated by the General_Category Mn/Me/Cf default,
+ * which is why it is by far the largest table.
+ */
+/** Joining_Type D, L or C: connects to the FOLLOWING character. */
+declare const JOINS_FORWARD_RANGES: readonly number[];
+/** Joining_Type D, R or C: connects to the PRECEDING character. */
+declare const JOINS_BACKWARD_RANGES: readonly number[];
+/** Joining_Type T: transparent, skipped when looking for a joining neighbour. */
+declare const JOINING_TRANSPARENT_RANGES: readonly number[];
+/** Joining_Type D, L or R: a cursive letter. Gates the whole joining path. */
+declare const JOINING_LETTER_RANGES: readonly number[];
+//#endregion
+export { JOINING_LETTER_RANGES, JOINING_TRANSPARENT_RANGES, JOINS_BACKWARD_RANGES, JOINS_FORWARD_RANGES };