superdoc 2.0.0-next.32 → 2.0.0-next.34

package/dist/chunks/{create-super-doc-ui-C0ZJE05U.cjs → create-super-doc-ui-DLyJzmj9.cjs}

@@ -1,3 +1,308 @@
+function getParagraphInlineDirection(attrs) {
+	const fromContext = attrs?.directionContext?.inlineDirection;
+	if (fromContext != null) return fromContext;
+	const ppRtl = attrs?.paragraphProperties?.rightToLeft;
+	if (ppRtl === true) return "rtl";
+	if (ppRtl === false) return "ltr";
+}
+var FALLBACK_PALETTE = [
+	"#1f6feb",
+	"#d1242f",
+	"#8250df",
+	"#bf3989",
+	"#1a7f37",
+	"#9a6700",
+	"#bc4c00",
+	"#0969da",
+	"#cf222e",
+	"#6639ba",
+	"#116329",
+	"#7d4e00"
+];
+const authorIdentityKey = (author) => {
+	if (!author) return "";
+	return `${typeof author.name === "string" ? author.name : ""} ${typeof author.email === "string" ? author.email : ""}`;
+};
+var hashString = (value) => {
+	let hash = 2166136261;
+	for (let i = 0; i < value.length; i += 1) {
+		hash ^= value.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
+};
+const fallbackAuthorColor = (author) => {
+	return FALLBACK_PALETTE[hashString(authorIdentityKey(author)) % FALLBACK_PALETTE.length];
+};
+var isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
+const composeAuthorColorResolver = (config) => {
+	if (!config || config.enabled === false) return void 0;
+	const overrides = config.overrides && typeof config.overrides === "object" ? config.overrides : void 0;
+	const resolve = typeof config.resolve === "function" ? config.resolve : void 0;
+	return (author) => {
+		const safeAuthor = author ?? {};
+		if (overrides) {
+			if (isNonEmptyString(safeAuthor.email) && isNonEmptyString(overrides[safeAuthor.email])) return overrides[safeAuthor.email];
+			if (isNonEmptyString(safeAuthor.name) && isNonEmptyString(overrides[safeAuthor.name])) return overrides[safeAuthor.name];
+		}
+		if (resolve) try {
+			const resolved = resolve(safeAuthor);
+			if (isNonEmptyString(resolved)) return resolved;
+		} catch {}
+		return fallbackAuthorColor(safeAuthor);
+	};
+};
+const TRACKED_CHANGE_CONFIGURABLE_SEMANTIC_COLOR_KEYS = [
+	"insertion",
+	"deletion",
+	"move",
+	"move-from",
+	"move-to",
+	"table-cell-insertion",
+	"table-cell-deletion",
+	"cell-merge",
+	"cell-split",
+	"image-insertion",
+	"image-deletion",
+	"image-property-change"
+];
+var CONFIGURABLE_SEMANTIC_COLOR_KEY_SET = new Set(TRACKED_CHANGE_CONFIGURABLE_SEMANTIC_COLOR_KEYS);
+const DRAWING_DIAGNOSTIC_CODES = {
+	externalImageDeferred: "render.media.external-image-deferred",
+	missingRelationship: "render.drawing.missing-relationship",
+	missingMediaPart: "render.media.missing-part",
+	unsupportedRelationshipType: "render.drawing.unsupported-relationship-type",
+	unsupportedMime: "render.media.unsupported-mime",
+	imageTooLarge: "render.media.image-too-large",
+	unsafeSvg: "render.media.unsafe-svg",
+	unsupportedFormat: "render.media.unsupported-format",
+	embeddedObjectNotSupported: "render.embedded-object-not-supported",
+	unsupportedObject: "render.drawing.unsupported-object",
+	vmlUnsupported: "render.drawing.vml-unsupported",
+	vmlImageUnsupported: "render.drawing.vml-image-unsupported",
+	unsupportedGeometryCommand: "render.drawing.unsupported-geometry-command",
+	anchorUnsupported: "render.drawing.anchor-unsupported",
+	wrapUnsupported: "render.drawing.wrap-unsupported",
+	altContentNoSupportedChoice: "render.drawing.altcontent-no-supported-choice",
+	groupChildUnsupported: "render.drawing.group-child-unsupported"
+};
+const DRAWING_DIAGNOSTIC_CODE_ALIASES = {
+	"render.media.missing-relationship": DRAWING_DIAGNOSTIC_CODES.missingRelationship,
+	"render.media.wrong-relationship-type": DRAWING_DIAGNOSTIC_CODES.unsupportedRelationshipType,
+	"render.media.unsupported-target": DRAWING_DIAGNOSTIC_CODES.unsupportedRelationshipType,
+	"render.media.invalid-image-size": DRAWING_DIAGNOSTIC_CODES.imageTooLarge,
+	"render.media-resolver-unavailable": DRAWING_DIAGNOSTIC_CODES.missingMediaPart,
+	"render.chart-not-supported": DRAWING_DIAGNOSTIC_CODES.unsupportedObject,
+	"render.textbox.vml-unsupported": DRAWING_DIAGNOSTIC_CODES.vmlUnsupported
+};
+const DRAWING_SUPPORT_TAXONOMY = {
+	inlineBitmap: {
+		family: "inlineBitmap",
+		support: "supported",
+		description: "wp:inline pic:pic with internal media and browser-safe MIME (PNG/JPEG; WebP/SVG once the host media resolver lands).",
+		contract: "ImageRun"
+	},
+	anchoredBitmap: {
+		family: "anchoredBitmap",
+		support: "supported",
+		description: "wp:anchor bitmap with anchor/wrap expressible by ImageAnchor/ImageWrap. Never silently inlined.",
+		contract: "ImageBlock"
+	},
+	imageChildInGroup: {
+		family: "imageChildInGroup",
+		support: "supported",
+		description: "Bitmap child of a supported DrawingML group/drawing wrapper. Supported only when the parent is.",
+		contract: "ImageDrawing"
+	},
+	vectorShape: {
+		family: "vectorShape",
+		support: "supported",
+		description: "Block/floating DrawingML preset/custom shape with the supported geometry/style subset.",
+		contract: "DrawingBlock",
+		drawingKind: "vectorShape"
+	},
+	shapeGroup: {
+		family: "shapeGroup",
+		support: "supported",
+		description: "DrawingML group whose rendered children are supported vector/image children.",
+		contract: "DrawingBlock",
+		drawingKind: "shapeGroup"
+	},
+	chart: {
+		family: "chart",
+		support: "supported",
+		description: "DrawingML chart projected into a ChartDrawing with parsed cached chart XML data. Complete Word chart fidelity remains deferred to chartFidelity.",
+		contract: "DrawingBlock",
+		drawingKind: "chart"
+	},
+	alternateContent: {
+		family: "alternateContent",
+		support: "supported",
+		description: "mc:AlternateContent traversal/select policy. Selected Choice/Fallback maps to its family contract; unselected branches preserved for save/reopen.",
+		contract: "selected-choice"
+	},
+	externalImage: {
+		family: "externalImage",
+		support: "fail-closed",
+		description: "External image relationship (r:link / TargetMode=\"External\"). Not fetched.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.externalImageDeferred
+	},
+	missingRelationship: {
+		family: "missingRelationship",
+		support: "fail-closed",
+		description: "Drawing references a relationship id absent from the owner part .rels.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.missingRelationship
+	},
+	missingMediaPart: {
+		family: "missingMediaPart",
+		support: "fail-closed",
+		description: "Relationship resolves but the target media part bytes are missing or empty.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.missingMediaPart
+	},
+	wrongRelationshipType: {
+		family: "wrongRelationshipType",
+		support: "fail-closed",
+		description: "Relationship exists but is not an image relationship type.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.unsupportedRelationshipType
+	},
+	unsupportedMime: {
+		family: "unsupportedMime",
+		support: "fail-closed",
+		description: "Media MIME outside the supported allowlist (incl. GIF/BMP/ICO).",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.unsupportedMime
+	},
+	oversizedMediaPart: {
+		family: "oversizedMediaPart",
+		support: "fail-closed",
+		description: "Media part exceeds the host byte-size policy before bytes are materialized.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.imageTooLarge
+	},
+	unsafeSvg: {
+		family: "unsafeSvg",
+		support: "fail-closed",
+		description: "SVG content rejected by the SVG safety policy.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.unsafeSvg
+	},
+	metafileOrTiff: {
+		family: "metafileOrTiff",
+		support: "fail-closed",
+		description: "EMF/WMF/TIFF and other non-browser-native formats with no approved conversion path.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.unsupportedFormat
+	},
+	embeddedObject: {
+		family: "embeddedObject",
+		support: "fail-closed",
+		description: "OLE / ActiveX / embedded package object.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.embeddedObjectNotSupported
+	},
+	smartArtOrDiagram: {
+		family: "smartArtOrDiagram",
+		support: "fail-closed",
+		description: "SmartArt / diagram / unknown external graphic-data object.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.unsupportedObject
+	},
+	vml: {
+		family: "vml",
+		support: "fail-closed",
+		description: "VML structure outside any supported image-like subset (default fail-closed policy).",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.vmlUnsupported
+	},
+	vmlImageLike: {
+		family: "vmlImageLike",
+		support: "fail-closed",
+		description: "Simple VML image references (v:imagedata) / watermark image metadata. Fail-closed unless a later change promotes a named subset with deterministic fixtures and exact oracles.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.vmlImageUnsupported
+	},
+	unsupportedGeometryCommand: {
+		family: "unsupportedGeometryCommand",
+		support: "fail-closed",
+		description: "Custom geometry command the extractor does not implement, e.g. arcTo.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.unsupportedGeometryCommand
+	},
+	unsupportedAnchorFields: {
+		family: "unsupportedAnchorFields",
+		support: "fail-closed",
+		description: "Anchor fields required for honest placement are unsupported (char-relative, alignment modes, etc.).",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.anchorUnsupported
+	},
+	unsupportedWrapFields: {
+		family: "unsupportedWrapFields",
+		support: "fail-closed",
+		description: "Wrap fields required for honest placement are unsupported (arbitrary wrap polygons, etc.).",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.wrapUnsupported
+	},
+	alternateContentNoSupportedChoice: {
+		family: "alternateContentNoSupportedChoice",
+		support: "fail-closed",
+		description: "mc:AlternateContent with no supported choice and no usable fallback.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.altContentNoSupportedChoice
+	},
+	groupChildUnsupported: {
+		family: "groupChildUnsupported",
+		support: "fail-closed",
+		description: "Unsupported child inside an otherwise-supported group. Supported siblings are not dropped.",
+		contract: "none",
+		diagnostic: DRAWING_DIAGNOSTIC_CODES.groupChildUnsupported
+	},
+	objectEditing: {
+		family: "objectEditing",
+		support: "deferred",
+		description: "Editing/mutation of anchored/vector objects.",
+		contract: "none"
+	},
+	customWrapPolygon: {
+		family: "customWrapPolygon",
+		support: "deferred",
+		description: "Full Word-compatible text wrapping for arbitrary custom wrap polygons.",
+		contract: "none"
+	},
+	chartFidelity: {
+		family: "chartFidelity",
+		support: "deferred",
+		description: "Complete chart fidelity (a dedicated chart effort owns the parsed subset).",
+		contract: "none"
+	},
+	vmlFidelity: {
+		family: "vmlFidelity",
+		support: "deferred",
+		description: "Complete VML fidelity.",
+		contract: "none"
+	},
+	decorativeAccessibilityUi: {
+		family: "decorativeAccessibilityUi",
+		support: "deferred",
+		description: "Full accessibility UI for decorative image semantics beyond preserving source data.",
+		contract: "none"
+	}
+};
+const DRAWING_FAMILIES = Object.keys(DRAWING_SUPPORT_TAXONOMY);
+const PAGE_CHECKPOINT_DEPENDENCY_CLASSES = Object.freeze([
+	"multiple-sections",
+	"furniture-page-tokens",
+	"non-balanceable-multi-column-sections",
+	"body-anchored-objects",
+	"footnotes",
+	"page-references",
+	"keep-constraints",
+	"tables",
+	"furniture-anchored-objects"
+]);
 function getV2TrackedChangeMutationImpact(event) {
 	if (event?.type !== "mutation:committed") return null;
 	const payload = event.origin === "history" ? event.result : event.receipt;
@@ -1262,6 +1567,11 @@ const HEAVY_DOC_READ_POLICY = [
 		note: "reserved: full sections list"
 	}
 ];
+var COMMENTS_CATALOG_PART_URIS = new Set([
+	"/word/comments.xml",
+	"/word/commentsExtended.xml",
+	"/word/commentsIds.xml"
+]);
 function isHeavyDocReadKey(key) {
 	return HEAVY_DOC_READ_POLICY.some((entry) => entry.match === "exact" ? entry.key === key : key.startsWith(entry.key));
 }
@@ -2331,6 +2641,8 @@ function createSuperDocUI(options) {
 	const superdoc = options.superdoc;
 	const optimisticInlineValues = /* @__PURE__ */ new Map();
 	const optimisticInlineToggles = /* @__PURE__ */ new Map();
+	let optimisticParagraphAlignment = null;
+	let optimisticParagraphAlignmentGeneration = 0;
 	const pendingInlineToggleMutations = [];
 	let lastOptimisticInlineSelectionSignature = null;
 	let optimisticInlineToggleGeneration = 0;
@@ -2977,6 +3289,11 @@ function createSuperDocUI(options) {
 		demandedHeavyReads.set(key, token);
 		scheduleAsyncRefresh();
 	};
+	const commentsCatalogMayHaveRows = () => {
+		const entry = asyncReads.get("comments");
+		if (!entry?.hasSettled) return entry?.inflightToken != null;
+		return Array.isArray(entry.value) && entry.value.length > 0;
+	};
 	const heavyReadDemandActive = (key, token) => demandedHeavyReads.get(key) === token;
 	const ensureContentControlsCatalog = (_reason) => {
 		demandHeavyDocRead("contentControls");
@@ -2993,20 +3310,28 @@ function createSuperDocUI(options) {
 	let lastTypingMutationAtMs = 0;
 	let heavyReadsHeldUntilIdle = false;
 	let heavyReadsTypingHoldSinceMs = 0;
+	let heavyReadCeilingReleaseActive = false;
 	let heavyReadCompletionRecomputeTimer = null;
 	const scheduleHeavyReadCompletionRecompute = () => {
 		if (disposed || heavyReadCompletionRecomputeTimer) return;
-		const startedAtMs = Date.now();
+		const startedAtMs = heavyReadsTypingHoldSinceMs || Date.now();
 		const attempt = () => {
 			heavyReadCompletionRecomputeTimer = null;
 			if (disposed) return;
 			const idleForMs = Date.now() - lastEditableMutationAtMs;
-			if ((foregroundMutationActive() || idleForMs < HEAVY_READ_IDLE_MS) && Date.now() - startedAtMs < HEAVY_READ_IDLE_CEILING_MS) {
+			const busy = foregroundMutationActive() || idleForMs < HEAVY_READ_IDLE_MS;
+			if (busy && Date.now() - startedAtMs < HEAVY_READ_IDLE_CEILING_MS) {
 				heavyReadCompletionRecomputeTimer = setTimeout(attempt, HEAVY_READ_IDLE_POLL_MS);
 				return;
 			}
 			heavyReadsHeldUntilIdle = false;
-			recompute();
+			heavyReadCeilingReleaseActive = busy;
+			try {
+				recompute();
+			} finally {
+				heavyReadCeilingReleaseActive = false;
+				heavyReadsTypingHoldSinceMs = 0;
+			}
 		};
 		heavyReadCompletionRecomputeTimer = setTimeout(attempt, 0);
 	};
@@ -3113,6 +3438,49 @@ function createSuperDocUI(options) {
 		invalidateDocumentContent();
 		recompute();
 	};
+	let pendingPostPaintContentRefresh = null;
+	let postPaintContentRefreshRunning = false;
+	let postPaintContentRefreshDrainToken = 0;
+	const resetPostPaintContentRefresh = () => {
+		pendingPostPaintContentRefresh = null;
+		postPaintContentRefreshRunning = false;
+		postPaintContentRefreshDrainToken += 1;
+	};
+	const schedulePostPaintContentRefresh = () => {
+		const editor = getEditor();
+		const readiness = editor?.documentMutationReadiness;
+		if (!editor || typeof readiness?.whenPainted !== "function") return;
+		pendingPostPaintContentRefresh = {
+			editor,
+			readiness,
+			afterEpoch: typeof readiness.getRenderEpoch === "function" ? safeCall(() => readiness.getRenderEpoch.call(readiness), null) : null
+		};
+		if (postPaintContentRefreshRunning) return;
+		postPaintContentRefreshRunning = true;
+		const drainToken = postPaintContentRefreshDrainToken;
+		const drain = async () => {
+			while (!disposed && drainToken === postPaintContentRefreshDrainToken) {
+				const request = pendingPostPaintContentRefresh;
+				pendingPostPaintContentRefresh = null;
+				if (!request) {
+					postPaintContentRefreshRunning = false;
+					return;
+				}
+				let paintCompleted = false;
+				try {
+					await request.readiness.whenPainted.call(request.readiness, typeof request.afterEpoch === "number" ? { afterEpoch: request.afterEpoch } : void 0);
+					paintCompleted = true;
+				} catch {}
+				if (disposed || drainToken !== postPaintContentRefreshDrainToken) return;
+				if (getEditor() !== request.editor) {
+					resetPostPaintContentRefresh();
+					return;
+				}
+				if (paintCompleted) invalidateDocumentContentAndRecompute();
+			}
+		};
+		drain();
+	};
 	const scheduleTypingDocumentContentInvalidation = () => {
 		if (typingContentInvalidationTimer) clearTimeout(typingContentInvalidationTimer);
 		typingContentInvalidationTimer = setTimeout(() => {
@@ -3200,7 +3568,7 @@ function createSuperDocUI(options) {
 					status: "pending"
 				};
 			}
-			if (heavyReadsHeldUntilIdle) {
+			if (heavyReadsHeldUntilIdle && !heavyReadCeilingReleaseActive) {
 				scheduleHeavyReadCompletionRecompute();
 				if (entry?.hasSettled) return {
 					value: entry.value,
@@ -3211,21 +3579,23 @@ function createSuperDocUI(options) {
 					status: "pending"
 				};
 			}
-			const nowMs = Date.now();
-			if (nowMs - lastTypingMutationAtMs < HEAVY_READ_IDLE_MS && (!heavyReadsTypingHoldSinceMs || nowMs - heavyReadsTypingHoldSinceMs < HEAVY_READ_IDLE_CEILING_MS)) {
-				if (!heavyReadsTypingHoldSinceMs) heavyReadsTypingHoldSinceMs = nowMs;
-				heavyReadsHeldUntilIdle = true;
-				scheduleHeavyReadCompletionRecompute();
-				if (entry?.hasSettled) return {
-					value: entry.value,
-					status: "stale"
-				};
-				return {
-					value: null,
-					status: "pending"
-				};
+			if (!heavyReadCeilingReleaseActive) {
+				const nowMs = Date.now();
+				if (nowMs - lastTypingMutationAtMs < HEAVY_READ_IDLE_MS && (!heavyReadsTypingHoldSinceMs || nowMs - heavyReadsTypingHoldSinceMs < HEAVY_READ_IDLE_CEILING_MS)) {
+					if (!heavyReadsTypingHoldSinceMs) heavyReadsTypingHoldSinceMs = nowMs;
+					heavyReadsHeldUntilIdle = true;
+					scheduleHeavyReadCompletionRecompute();
+					if (entry?.hasSettled) return {
+						value: entry.value,
+						status: "stale"
+					};
+					return {
+						value: null,
+						status: "pending"
+					};
+				}
+				heavyReadsTypingHoldSinceMs = 0;
 			}
-			heavyReadsTypingHoldSinceMs = 0;
 		}
 		if (foregroundMutationActive()) {
 			scheduleForegroundAsyncRetry();
@@ -3297,6 +3667,7 @@ function createSuperDocUI(options) {
 	const syncCoordinatorEditor = () => {
 		const editor = getEditor();
 		if (editor === lastCoordinatorEditor) return;
+		resetPostPaintContentRefresh();
 		reviewMutationReconciler.reset();
 		reviewMutationToken = {};
 		lastCoordinatorEditor = editor;
@@ -3310,6 +3681,7 @@ function createSuperDocUI(options) {
 		pendingEffectiveInlineRead = null;
 		lastEffectiveInlineReadKey = null;
 		heldSettledInlineValues = null;
+		optimisticParagraphAlignment = null;
 		pendingSelectionSeedValidationToken = null;
 		coldAsyncReadDeferrals.clear();
 		demandedHeavyReads.clear();
@@ -4215,6 +4587,7 @@ function createSuperDocUI(options) {
 				styleName: active.styleName
 			};
 		}
+		if (descriptor.id === "text-align") return readToolbarParagraphAlignment(doc, selection$1);
 		if (descriptor.id === "link") return readActiveLinkHref(doc, selection$1) ?? void 0;
 	};
 	const readListStateSnapshotForBlock = (doc, blockId, story) => {
@@ -4266,22 +4639,160 @@ function createSuperDocUI(options) {
 	const readNodeById = (doc, blockId, story) => {
 		if (!doc) return {
 			value: null,
-			status: "ready"
+			status: "ready",
+			refreshing: false
 		};
 		const storySignature = storyLocatorSignature(story);
 		const isBodyStory = storySignature === "story:body";
 		if (isBodyStory && typeof doc.getNodeById !== "function") return {
 			value: null,
-			status: "ready"
+			status: "ready",
+			refreshing: false
 		};
 		if (!isBodyStory && typeof doc.getNode !== "function") return {
 			value: null,
-			status: "ready"
+			status: "ready",
+			refreshing: false
 		};
-		return readAsync(`node:${storySignature}:${blockId}`, contentToken(), () => isBodyStory ? doc.getNodeById({
+		const key = `node:${storySignature}:${blockId}`;
+		const token = contentToken();
+		const read = readAsync(key, token, () => isBodyStory ? doc.getNodeById({
 			nodeId: blockId,
 			nodeType: "paragraph"
 		}) : doc.getNode(paragraphTarget(blockId, story)), (raw) => raw && typeof raw === "object" ? raw : null);
+		const entry = asyncReads.get(key);
+		return {
+			...read,
+			refreshing: read.status === "stale" && entry?.inflightToken === token && entry.failedToken !== token
+		};
+	};
+	const normalizeParagraphAlignment = (value) => {
+		return value === "left" || value === "center" || value === "right" || value === "justify" ? value : void 0;
+	};
+	const isProjectionResolvedParagraphAlignment = (value) => {
+		return value === "start" || value === "end" || value === "distributed" || value === "numTab" || value === "lowKashida" || value === "mediumKashida" || value === "highKashida" || value === "thaiDistribute";
+	};
+	const readEffectiveParagraphAlignments = (selection$1, blockIds) => {
+		const host = getHost();
+		const readByIds = host?.readMountedProjectionBlocksByIds;
+		if (typeof readByIds !== "function") return null;
+		const story = selectionStoryLocator(selection$1);
+		const blocks = safeCall(() => story ? readByIds.call(host, [...blockIds], story) : readByIds.call(host, [...blockIds]), null);
+		if (!Array.isArray(blocks)) return /* @__PURE__ */ new Map();
+		const projectionBlocks = collectProjectionTextBlocks(blocks);
+		const alignments = /* @__PURE__ */ new Map();
+		for (const blockId of blockIds) {
+			const block = projectionBlocks.find((candidate) => projectionBlockMatchesId(candidate, blockId));
+			if (!block) continue;
+			const attrs = block.attrs;
+			const alignment = normalizeParagraphAlignment(attrs?.alignment);
+			const inlineDirection = getParagraphInlineDirection(attrs);
+			alignments.set(blockId, alignment ?? (inlineDirection === "rtl" ? "right" : "left"));
+		}
+		return alignments;
+	};
+	const readParagraphAlignment = (doc, blockId, story, effectiveAlignments) => {
+		const { value: result, status, refreshing } = readNodeById(doc, blockId, story);
+		const effective = effectiveAlignments?.get(blockId);
+		if (status === "pending") return effective ? {
+			status: "uniform",
+			value: effective
+		} : { status: "pending" };
+		if (status === "stale" && !refreshing) return { status: "pending" };
+		if (status === "stale" && effective) return {
+			status: "uniform",
+			value: effective
+		};
+		if (status === "stale" && effectiveAlignments && !effective) return { status: "unavailable" };
+		if (!result) return { status: "unavailable" };
+		const node = result.node;
+		if (!node) return { status: "unavailable" };
+		const kind = node.kind;
+		if (kind !== "paragraph" && kind !== "heading") return { status: "unavailable" };
+		const payload = node[kind];
+		if (!payload || typeof payload !== "object") return { status: "unavailable" };
+		const directAlignment = payload.props?.alignment;
+		if (directAlignment == null) return effective ? {
+			status: "uniform",
+			value: effective
+		} : { status: "unavailable" };
+		const alignment = normalizeParagraphAlignment(directAlignment);
+		if (alignment) return {
+			status: "uniform",
+			value: alignment
+		};
+		if (isProjectionResolvedParagraphAlignment(directAlignment) && effective) return {
+			status: "uniform",
+			value: effective
+		};
+		return { status: "unavailable" };
+	};
+	const readUniformParagraphAlignment = (doc, selection$1) => {
+		const blockIds = selectionBlockIds(selection$1);
+		if (blockIds.length === 0 || !canProbeEverySelectedBlock(blockIds)) return { status: "unavailable" };
+		const story = selectionStory(selection$1);
+		const effectiveAlignments = readEffectiveParagraphAlignments(selection$1, blockIds);
+		const first = readParagraphAlignment(doc, blockIds[0], story, effectiveAlignments);
+		if (first.status !== "uniform") return first;
+		for (const blockId of blockIds.slice(1)) {
+			const next = readParagraphAlignment(doc, blockId, story, effectiveAlignments);
+			if (next.status !== "uniform") return next;
+			if (next.value !== first.value) return { status: "mixed" };
+		}
+		return first;
+	};
+	const paragraphAlignmentSelectionSignature = (selection$1) => {
+		const blockIds = selectionBlockIds(selection$1);
+		if (blockIds.length === 0) return null;
+		return `${storyLocatorSignature(selectionStory(selection$1))}:${blockIds.join(",")}`;
+	};
+	const readToolbarParagraphAlignment = (doc, selection$1) => {
+		const resolution = readUniformParagraphAlignment(doc, selection$1);
+		const resolved = resolution.status === "uniform" ? resolution.value : void 0;
+		const optimistic = optimisticParagraphAlignment;
+		if (!optimistic) return resolved;
+		const selectionSignature$1 = paragraphAlignmentSelectionSignature(selection$1);
+		if (selectionSignature$1 && selectionSignature$1 !== optimistic.selectionSignature) {
+			optimisticParagraphAlignment = null;
+			return resolved;
+		}
+		if (!selectionSignature$1) return optimistic.value;
+		if (!optimistic.settled) return optimistic.value;
+		if (resolution.status !== "pending") {
+			optimisticParagraphAlignment = null;
+			return resolved;
+		}
+		return optimistic.value;
+	};
+	const armOptimisticParagraphAlignment = (selection$1, payload) => {
+		const alignment = normalizeParagraphAlignment(payload);
+		const selectionSignature$1 = paragraphAlignmentSelectionSignature(selection$1);
+		const blockIds = selectionBlockIds(selection$1);
+		if (!alignment || !selectionSignature$1 || blockIds.length === 0) return null;
+		const generation = ++optimisticParagraphAlignmentGeneration;
+		optimisticParagraphAlignment = {
+			selectionSignature: selectionSignature$1,
+			value: alignment,
+			generation,
+			settled: false,
+			canReconcile: canProbeEverySelectedBlock(blockIds)
+		};
+		recompute();
+		return generation;
+	};
+	const settleOptimisticParagraphAlignment = (generation, result) => {
+		if (generation == null) return;
+		const optimistic = optimisticParagraphAlignment;
+		if (!optimistic || optimistic.generation !== generation) return;
+		if (!commandResultSucceeded(result)) {
+			optimisticParagraphAlignment = null;
+			return;
+		}
+		if (!optimistic.canReconcile) {
+			optimisticParagraphAlignment = null;
+			return;
+		}
+		optimistic.settled = true;
 	};
 	const resolveListMembershipForBlockAsync = async (doc, blockId, story) => {
 		const listsApi = doc?.lists;
@@ -4932,12 +5443,12 @@ function createSuperDocUI(options) {
 					}
 					return;
 				}
+				if (type === "mutation:committed" || type === "collaboration:remote-changed") lastEditableMutationAtMs = Date.now();
 				if (type === "mutation:committed") {
-					lastEditableMutationAtMs = Date.now();
 					clearAuthoritativeTrackChangesRetry();
 					reviewMutationToken = {};
 				}
-				if (type === "mutation:committed" || type === "save:completed") {
+				if (type === "mutation:committed" || type === "save:completed" || type === "collaboration:remote-changed") {
 					const impact = type === "mutation:committed" ? getV2TrackedChangeMutationImpact(event) : null;
 					const supersedesPendingReviewReconcile = type === "mutation:committed" && reviewMutationReconciler.getPendingIds().size > 0;
 					if (impact?.removedIds.size) markPostDecisionTrackChanges(new Set(impact.removedIds), event.receipt);
@@ -4967,13 +5478,20 @@ function createSuperDocUI(options) {
 						}
 					}
 					if (authoritativeHistoryImpact) return;
-					if (type === "mutation:committed" && isEditableTextMutationEvent(event)) {
-						lastTypingMutationAtMs = Date.now();
+					const isTypingBurst = type === "mutation:committed" && isEditableTextMutationEvent(event) || type === "collaboration:remote-changed" && Array.isArray(event.changedStoryIds) && event.changedStoryIds.length > 0;
+					if (isTypingBurst) lastTypingMutationAtMs = Date.now();
+					if (type === "mutation:committed" && isTypingBurst) {
 						scheduleTypingDocumentContentInvalidation();
 						return;
 					}
 					if (impact?.removedIds.size && impact.upsertIds.size === 0) return;
-					invalidateDocumentContentAndRecompute();
+					if (type === "collaboration:remote-changed" || type === "mutation:committed" && !isTypingBurst) schedulePostPaintContentRefresh();
+					const remoteCommentsPartChanged = type === "collaboration:remote-changed" && Array.isArray(event.changedPartUris) && event.changedPartUris.some((partUri) => typeof partUri === "string" && COMMENTS_CATALOG_PART_URIS.has(partUri));
+					const loadedCommentAnchorsMayHaveChanged = type === "collaboration:remote-changed" && Array.isArray(event.changedStoryIds) && event.changedStoryIds.length > 0 && commentsCatalogMayHaveRows();
+					if (remoteCommentsPartChanged && !isTypingBurst) heavyReadsHeldUntilIdle = true;
+					invalidateDocumentContent();
+					if (remoteCommentsPartChanged || loadedCommentAnchorsMayHaveChanged) demandHeavyDocRead("comments");
+					recompute();
 				}
 			});
 			if (typeof off === "function") detachHostEvents = off;
@@ -6100,7 +6618,13 @@ function createSuperDocUI(options) {
 				return false;
 			}
 		}
-		if (descriptor.blockParagraph) return settleCommandExecution(executeBlockParagraph(descriptor, op, normalized));
+		if (descriptor.blockParagraph) {
+			const result = executeBlockParagraph(descriptor, op, normalized);
+			const optimisticAlignmentGeneration = descriptor.blockParagraph.kind === "alignment" && commandResultSucceeded(result) ? armOptimisticParagraphAlignment(state.selection, normalized) : null;
+			return settleCommandExecution(result, (settled) => {
+				settleOptimisticParagraphAlignment(optimisticAlignmentGeneration, settled);
+			});
+		}
 		if (descriptor.list) return settleCommandExecution(executeListCommand(descriptor, op));
 		if (descriptor.link) return settleCommandExecution(executeLinkCommand(normalized));
 		if (descriptor.create) return settleCommandExecution(executeCreateCommand(descriptor, op, normalized));
@@ -8206,6 +8730,12 @@ Object.defineProperty(exports, "BUILT_IN_COMMAND_IDS", {
 		return BUILT_IN_COMMAND_IDS;
 	}
 });
+Object.defineProperty(exports, "composeAuthorColorResolver", {
+	enumerable: true,
+	get: function() {
+		return composeAuthorColorResolver;
+	}
+});
 Object.defineProperty(exports, "createSuperDocUI", {
 	enumerable: true,
 	get: function() {