@univerjs/docs 1.0.0-insiders.20260809-70eefdd → 1.0.0-rc.0

package/lib/index.js

@@ -1,6 +1,8 @@
-import { AlignTypeH, BuildTextUtils, ColumnSeparatorType, CommandType, CustomRangeType, DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY, DOCS_NORMAL_EDITOR_UNIT_ID_KEY, DataStreamTreeTokenType, DeleteDirection, Disposable, DisposableCollection, DocumentFlavor, DocxBreakType, DrawingTypeEnum, ICommandService, IConfigService, IUndoRedoService, IUniverInstanceService, Inject, Injector, JSONX, LocaleService, MemoryCursor, ObjectRelativeFromH, ObjectRelativeFromV, Optional, PAGE_SIZE, PageOrientType, PaperType, Plugin, PositionedObjectLayoutType, RESTORE_INSERTED_PARAGRAPH_IDS, RedoCommandId, RxDisposable, SectionType, TRADITIONAL_DOCUMENT_DEFAULT_MARGIN, TextX, TextXActionType, Tools, UndoCommandId, UniverInstanceType, UpdateDocsAttributeType, composeInterceptors, containsInteriorInsertionOffset, createIdentifier, createInterceptorKey, createParagraphId, createSectionId, generateRandomId, getBlockRangeInterval, getColumnGroupRangeInterval, getParagraphContentStartOffset, getRichTextEditPath, getSectionHeaderFooterReferenceKey, getTableRangeInterval, isInternalEditorID, merge, remove, resolveSectionHeaderFooterReference, toDisposable, validateDocBodyStructure } from "@univerjs/core";
-import { DocumentSkeleton, DocumentViewModel, IRenderManagerService, NORMAL_TEXT_SELECTION_PLUGIN_STYLE } from "@univerjs/engine-render";
-import { BehaviorSubject, Subject, takeUntil } from "rxjs";
+import { AlignTypeH, BooleanNumber, BuildTextUtils, ColumnSeparatorType, CommandType, CustomCommandExecutionError, CustomRangeType, DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY, DOCS_NORMAL_EDITOR_UNIT_ID_KEY, DataStreamTreeTokenType, DeleteDirection, DependentOn, Disposable, DisposableCollection, DocumentDataModel, DocumentFlavor, DocxBreakType, DrawingTypeEnum, ErrorService, ICommandService, IConfigService, ILogService, IPermissionService, IResourceManagerService, IUndoRedoService, IUniverInstanceService, Inject, Injector, JSON1, JSONX, LocaleService, MemoryCursor, ObjectPermissionRuleModel, ObjectPermissionService, ObjectRelativeFromH, ObjectRelativeFromV, Optional, PAGE_SIZE, PageOrientType, PaperType, PermissionStatus, Plugin, PositionedObjectLayoutType, RESTORE_INSERTED_PARAGRAPH_IDS, RedoCommandId, RxDisposable, SectionType, TRADITIONAL_DOCUMENT_DEFAULT_MARGIN, TextX, TextXActionType, Tools, UndoCommandId, UniverInstanceType, UpdateDocsAttributeType, composeInterceptors, containsInteriorInsertionOffset, createIdentifier, createInterceptorKey, createParagraphId, createSectionId, generateRandomId, getBlockRangeInterval, getColumnGroupRangeInterval, getParagraphContentStartOffset, getParagraphContentStartOffsets, getRichTextEditPath, getSectionHeaderFooterReferenceKey, getTableRangeInterval, isInternalEditorID, merge, remove, requestImmediateMacroTask, resolveSectionHeaderFooterReference, toDisposable, validateDocBodyStructure, validateDocumentStructure } from "@univerjs/core";
+import { DocumentLayoutSession, DocumentSkeleton, DocumentViewModel, FontCache, IRenderManagerService, NORMAL_TEXT_SELECTION_PLUGIN_STYLE, getDocsCustomBlockRenderViewport, getFontStyleString, setDocsCustomBlockRenderViewportProvider } from "@univerjs/engine-render";
+import { BehaviorSubject, Observable, Subject, shareReplay, takeUntil } from "rxjs";
+import { UnitAction, UnitObject } from "@univerjs/protocol";
+import { ChannelService, fromModule, toModule } from "@univerjs/rpc";
 
 //#region src/commands/operations/text-selection.operation.ts
 const SetTextSelectionsOperation = {
@@ -106,9 +108,9 @@ let DocSelectionManagerService = class DocSelectionManagerService extends RxDisp
 	getSelectionInfo(params = this._currentSelection) {
 		return this._getTextRanges(params);
 	}
-	refreshSelection(params = this._currentSelection) {
+	refreshSelection(params = this._currentSelection, isEditing = false) {
 		if (params == null) return;
-		this._refresh(params);
+		this._refresh(params, isEditing);
 	}
 	__TEST_ONLY_setCurrentSelection(param) {
 		this._currentSelection = param;
@@ -160,8 +162,19 @@ let DocSelectionManagerService = class DocSelectionManagerService extends RxDisp
 			options
 		});
 	}
+	/**
+	* Replaces logical selection state without rebuilding render ranges. Atomic
+	* external mutations use this before applying document actions so layout can
+	* follow transformed offsets, then refresh after new geometry is available.
+	*/
+	replaceSelectionInfoWithoutRefresh(selectionInfo, params = this._currentSelection) {
+		if (params == null) return;
+		this._replaceByParam({
+			...selectionInfo,
+			...params
+		});
+	}
 	__replaceTextRangesWithNoRefresh(textSelectionInfo, search) {
-		if (this._currentSelection == null) return;
 		const params = {
 			...textSelectionInfo,
 			...search
@@ -196,7 +209,7 @@ let DocSelectionManagerService = class DocSelectionManagerService extends RxDisp
 		const { unitId, subUnitId = "" } = param;
 		return (_this$_textSelectionI = this._textSelectionInfo.get(unitId)) === null || _this$_textSelectionI === void 0 ? void 0 : _this$_textSelectionI.get(subUnitId);
 	}
-	_refresh(param) {
+	_refresh(param, isEditing = false) {
 		const allTextSelectionInfo = this._getTextRanges(param);
 		if (allTextSelectionInfo == null) return;
 		const { textRanges, rectRanges, options } = allTextSelectionInfo;
@@ -206,8 +219,11 @@ let DocSelectionManagerService = class DocSelectionManagerService extends RxDisp
 			unitId,
 			subUnitId,
 			docRanges,
-			isEditing: false,
-			options
+			isEditing,
+			options: (options === null || options === void 0 ? void 0 : options.forceFocus) ? {
+				...options,
+				forceFocus: false
+			} : options
 		});
 	}
 	_replaceByParam(insertParam) {
@@ -225,14 +241,645 @@ let DocSelectionManagerService = class DocSelectionManagerService extends RxDisp
 };
 DocSelectionManagerService = __decorate([__decorateParam(0, ICommandService), __decorateParam(1, IUniverInstanceService)], DocSelectionManagerService);
 
+//#endregion
+//#region src/commands/mutations/core-editing.mutation-id.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+const RICH_TEXT_EDITING_MUTATION_ID = "doc.mutation.rich-text-editing";
+
+//#endregion
+//#region src/services/document-layout-snapshot.ts
+function projectCustomBlock(block) {
+	const { docxRawXml: _docxRawXml, docxExportTs: _docxExportTs, ...layoutBlock } = block;
+	return layoutBlock;
+}
+function projectDocumentBody(body) {
+	const { docxRawCustomBlocks: _docxRawCustomBlocks, docxRawBlocks: _docxRawBlocks, docxExportExcludedRanges: _docxExportExcludedRanges, payloads: _payloads, customBlocks, ...layoutBody } = body;
+	return {
+		...layoutBody,
+		...customBlocks == null ? {} : { customBlocks: customBlocks.map(projectCustomBlock) }
+	};
+}
+function projectHeader(header) {
+	return {
+		...header,
+		body: projectDocumentBody(header.body)
+	};
+}
+function projectFooter(footer) {
+	return {
+		...footer,
+		body: projectDocumentBody(footer.body)
+	};
+}
+/**
+* Builds the model snapshot owned by the layout Worker. Exchange-only payloads
+* remain in the authoritative Main model and are deliberately excluded from
+* the structured-clone boundary because they do not affect document geometry.
+*/
+function createDocumentLayoutSnapshot(snapshot) {
+	const { resources: _resources, body, headers, footers, ...layoutSnapshot } = snapshot;
+	return {
+		...layoutSnapshot,
+		...body == null ? {} : { body: projectDocumentBody(body) },
+		...headers == null ? {} : { headers: Object.fromEntries(Object.entries(headers).map(([headerId, header]) => [headerId, projectHeader(header)])) },
+		...footers == null ? {} : { footers: Object.fromEntries(Object.entries(footers).map(([footerId, footer]) => [footerId, projectFooter(footer)])) }
+	};
+}
+
+//#endregion
+//#region src/services/doc-layout-executor.service.ts
+var _DocLayoutExecutorService;
+let DocLayoutExecutorType = /* @__PURE__ */ function(DocLayoutExecutorType) {
+	DocLayoutExecutorType["MAIN_THREAD"] = "main-thread";
+	DocLayoutExecutorType["WORKER"] = "worker";
+	return DocLayoutExecutorType;
+}({});
+let DocLayoutSessionStatus = /* @__PURE__ */ function(DocLayoutSessionStatus) {
+	DocLayoutSessionStatus["ACCEPTED"] = "accepted";
+	DocLayoutSessionStatus["NOT_FOUND"] = "not-found";
+	DocLayoutSessionStatus["RESNAPSHOT_REQUIRED"] = "resnapshot-required";
+	DocLayoutSessionStatus["SUPERSEDED"] = "superseded";
+	return DocLayoutSessionStatus;
+}({});
+let DocLayoutExecutorState = /* @__PURE__ */ function(DocLayoutExecutorState) {
+	DocLayoutExecutorState["UNREGISTERED"] = "unregistered";
+	DocLayoutExecutorState["INITIALIZING"] = "initializing";
+	DocLayoutExecutorState["ACTIVE"] = "active";
+	DocLayoutExecutorState["RECOVERING"] = "recovering";
+	DocLayoutExecutorState["FAILED"] = "failed";
+	return DocLayoutExecutorState;
+}({});
+function areShallowRecordsEqual(left, right) {
+	const leftRecord = left;
+	const rightRecord = right;
+	const leftKeys = Object.keys(leftRecord);
+	const rightKeys = Object.keys(rightRecord);
+	return leftKeys.length === rightKeys.length && leftKeys.every((key) => leftRecord[key] === rightRecord[key]);
+}
+function createRecordPatch(previous, current) {
+	const upserts = {};
+	const removals = [];
+	for (const [key, value] of Object.entries(current)) if (previous[key] == null || !areShallowRecordsEqual(previous[key], value)) upserts[key] = value;
+	for (const key of Object.keys(previous)) if (current[key] == null) removals.push(key);
+	return {
+		removals,
+		upserts
+	};
+}
+function getCustomRangePresentationKey$1(entry) {
+	return JSON.stringify([entry.segmentId, entry.rangeId]);
+}
+function toCustomRangePresentationMap(entries) {
+	return new Map(entries.map((entry) => [getCustomRangePresentationKey$1(entry), entry]));
+}
+function createCustomRangePresentationPatch(previous, current) {
+	const upserts = [];
+	const removals = [];
+	for (const [key, entry] of current) {
+		const previousEntry = previous.get(key);
+		if (previousEntry == null || !areShallowRecordsEqual(previousEntry.presentation, entry.presentation)) upserts.push(entry);
+	}
+	for (const [key, entry] of previous) if (!current.has(key)) removals.push({
+		segmentId: entry.segmentId,
+		rangeId: entry.rangeId
+	});
+	return {
+		removals,
+		upserts
+	};
+}
+function isRichTextEditingMutationParams(value) {
+	return typeof value === "object" && value != null && "unitId" in value && typeof value.unitId === "string" && "actions" in value;
+}
+function collectCustomBlockViewports(dataModel) {
+	var _snapshot$body;
+	const snapshot = dataModel.getSnapshot();
+	const documentStyle = snapshot.documentStyle;
+	const viewports = {};
+	for (const customBlock of ((_snapshot$body = snapshot.body) === null || _snapshot$body === void 0 ? void 0 : _snapshot$body.customBlocks) ?? []) {
+		var _snapshot$drawings, _documentStyle$pageSi;
+		const drawing = (_snapshot$drawings = snapshot.drawings) === null || _snapshot$drawings === void 0 ? void 0 : _snapshot$drawings[customBlock.blockId];
+		if (drawing == null) continue;
+		const viewport = getDocsCustomBlockRenderViewport(dataModel.getUnitId(), customBlock.blockId, {
+			fallbackHeight: drawing.docTransform.size.height ?? 0,
+			fallbackWidth: drawing.docTransform.size.width ?? 0,
+			pageMarginLeft: documentStyle.marginLeft,
+			pageMarginRight: documentStyle.marginRight,
+			pageWidth: (_documentStyle$pageSi = documentStyle.pageSize) === null || _documentStyle$pageSi === void 0 ? void 0 : _documentStyle$pageSi.width
+		});
+		if (viewport != null) viewports[customBlock.blockId] = { ...viewport };
+	}
+	return viewports;
+}
+let DocLayoutExecutorService = _DocLayoutExecutorService = class DocLayoutExecutorService extends Disposable {
+	constructor(_univerInstanceService, _commandService, _localeService, _logService) {
+		super();
+		this._univerInstanceService = _univerInstanceService;
+		this._commandService = _commandService;
+		this._localeService = _localeService;
+		this._logService = _logService;
+		_defineProperty(this, "_executor", null);
+		_defineProperty(this, "_executorReady", null);
+		_defineProperty(this, "_recoveryFailure", null);
+		_defineProperty(this, "_sessionEpoch", 0);
+		_defineProperty(this, "_sessions", /* @__PURE__ */ new Map());
+		_defineProperty(this, "_hydrationSamples", /* @__PURE__ */ new Map());
+		_defineProperty(this, "_customRangePresentationProviders", /* @__PURE__ */ new Set());
+		_defineProperty(this, "_executorStatus$", new BehaviorSubject({
+			state: "unregistered",
+			executor: null,
+			diagnostic: null,
+			recoveryUnitId: null
+		}));
+		_defineProperty(this, "executorStatus$", this._executorStatus$.asObservable());
+		this.disposeWithMe(this._univerInstanceService.getTypeOfUnitAdded$(UniverInstanceType.UNIVER_DOC).subscribe(({ unit }) => this._createSessionIfEligible(unit)));
+		this.disposeWithMe(this._univerInstanceService.getTypeOfUnitDisposed$(UniverInstanceType.UNIVER_DOC).subscribe((unit) => this._disposeSession(unit.getUnitId())));
+		this.disposeWithMe(this._commandService.onCommandExecuted((command) => {
+			if (command.id !== "doc.mutation.rich-text-editing") return;
+			const params = command.params;
+			if (!isRichTextEditingMutationParams(params)) {
+				this._logService.warn("[DocLayoutExecutorService]: ignored malformed document mutation parameters.");
+				return;
+			}
+			this._enqueueCommittedMutation(params);
+		}));
+		this.disposeWithMe(this._localeService.localeChanged$.subscribe(() => {
+			for (const unitId of this._sessions.keys()) {
+				const dataModel = this._getEligibleModel(unitId);
+				if (dataModel != null) this._replaceSession(dataModel).catch((error) => {
+					this._logService.error("[DocLayoutExecutorService]: failed to refresh Worker locale.", error);
+				});
+			}
+		}));
+	}
+	register(executor) {
+		if (this._executor != null) throw new Error("A document layout executor is already registered.");
+		this._executor = executor;
+		this._recoveryFailure = null;
+		this._executorStatus$.next({
+			state: "initializing",
+			executor: executor.type,
+			diagnostic: null,
+			recoveryUnitId: null
+		});
+		const executorReady = executor.initialize();
+		this._executorReady = executorReady;
+		executorReady.then(() => {
+			if (this._executor === executor) this._executorStatus$.next({
+				state: "active",
+				executor: executor.type,
+				diagnostic: null,
+				recoveryUnitId: null
+			});
+		}).catch((error) => {
+			if (this._executor !== executor) return;
+			this._executor = null;
+			this._executorReady = null;
+			this._disposeManagedSessions();
+			this._sessions.clear();
+			const diagnostic = error instanceof Error ? error.message : String(error);
+			this._executorStatus$.next({
+				state: "failed",
+				executor: executor.type,
+				diagnostic,
+				recoveryUnitId: null
+			});
+			this._logService.error("[DocLayoutExecutorService]: document layout executor initialization failed.", error);
+		});
+		for (const unit of this._univerInstanceService.getAllUnitsForType(UniverInstanceType.UNIVER_DOC)) this._createSessionIfEligible(unit);
+		return toDisposable(() => {
+			if (this._executor === executor) {
+				this._executor = null;
+				this._executorReady = null;
+				this._disposeManagedSessions();
+				this._sessions.clear();
+				this._executorStatus$.next({
+					state: "unregistered",
+					executor: null,
+					diagnostic: null,
+					recoveryUnitId: null
+				});
+			}
+		});
+	}
+	getExecutor() {
+		return this._executor;
+	}
+	getExecutorStatus() {
+		return this._executorStatus$.value;
+	}
+	registerCustomRangePresentationProvider(provider) {
+		this._customRangePresentationProviders.add(provider);
+		return toDisposable(() => this._customRangePresentationProviders.delete(provider));
+	}
+	async getPerformanceMetrics(unitId) {
+		var _this$_executor;
+		const executorMetrics = await ((_this$_executor = this._executor) === null || _this$_executor === void 0 ? void 0 : _this$_executor.getPerformanceMetrics(unitId));
+		return {
+			hydrationMs: [...this._hydrationSamples.get(unitId) ?? []],
+			mutationTransferMs: [...(executorMetrics === null || executorMetrics === void 0 ? void 0 : executorMetrics.mutationTransferMs) ?? []],
+			patchTransferMs: [...(executorMetrics === null || executorMetrics === void 0 ? void 0 : executorMetrics.patchTransferMs) ?? []],
+			snapshotTransferMs: [...(executorMetrics === null || executorMetrics === void 0 ? void 0 : executorMetrics.snapshotTransferMs) ?? []]
+		};
+	}
+	async resetPerformanceMetrics(unitId) {
+		var _this$_executor2;
+		this._hydrationSamples.delete(unitId);
+		await ((_this$_executor2 = this._executor) === null || _this$_executor2 === void 0 ? void 0 : _this$_executor2.resetPerformanceMetrics(unitId));
+	}
+	recordHydrationDuration(unitId, durationMs) {
+		this._appendPerformanceSample(this._hydrationSamples, unitId, durationMs);
+	}
+	async recoverExecutor(unitId, diagnostic) {
+		const executor = this._requireExecutor();
+		this._executorStatus$.next({
+			state: "recovering",
+			executor: executor.type,
+			diagnostic,
+			recoveryUnitId: unitId
+		});
+		for (const session of this._sessions.values()) this._markSessionDisposed(session);
+		this._sessions.clear();
+		this._hydrationSamples.clear();
+		try {
+			const executorReady = executor.recover();
+			this._executorReady = executorReady;
+			await executorReady;
+		} catch (error) {
+			const recoveryDiagnostic = error instanceof Error ? error.message : String(error);
+			this._executor = null;
+			this._executorReady = null;
+			this._recoveryFailure = {
+				diagnostic: recoveryDiagnostic,
+				unitId
+			};
+			this._executorStatus$.next({
+				state: "recovering",
+				executor: executor.type,
+				diagnostic: recoveryDiagnostic,
+				recoveryUnitId: unitId
+			});
+			throw error;
+		}
+	}
+	completeRecovery(unitId) {
+		var _this$_recoveryFailur;
+		const status = this._executorStatus$.value;
+		if (status.state !== "recovering" || status.recoveryUnitId !== unitId) return;
+		const recoveryFailure = ((_this$_recoveryFailur = this._recoveryFailure) === null || _this$_recoveryFailur === void 0 ? void 0 : _this$_recoveryFailur.unitId) === unitId ? this._recoveryFailure : null;
+		this._recoveryFailure = null;
+		this._executorStatus$.next({
+			state: recoveryFailure == null ? "active" : "failed",
+			executor: status.executor,
+			diagnostic: (recoveryFailure === null || recoveryFailure === void 0 ? void 0 : recoveryFailure.diagnostic) ?? null,
+			recoveryUnitId: null
+		});
+	}
+	async startLayout(identity, options, budgetMs) {
+		const { unitId } = identity;
+		const executor = this._executor;
+		const dataModel = this._getEligibleModel(unitId);
+		if (executor == null || dataModel == null) return null;
+		let session = this._sessions.get(unitId);
+		if (session != null && session.sourceMutationRevision !== dataModel.getMutationRevision()) session.needsResnapshot = true;
+		if (session == null || session.needsResnapshot) session = await this._replaceSession(dataModel);
+		let result = await this._startSynchronizedLayout(executor, session, identity, options, budgetMs);
+		if (result.status === "not-found" || result.status === "resnapshot-required") {
+			session = await this._replaceSession(dataModel);
+			result = await this._startSynchronizedLayout(executor, session, identity, options, budgetMs);
+		}
+		return result;
+	}
+	stepLayout(request) {
+		return this._requireExecutor().stepLayout(request);
+	}
+	publishBacklog(request) {
+		return this._requireExecutor().publishBacklog(request);
+	}
+	getLayoutPage(request) {
+		return this._requireExecutor().getLayoutPage(request);
+	}
+	cancelLayout(request) {
+		const executor = this._executor;
+		return executor == null ? Promise.resolve() : executor.cancelLayout(request);
+	}
+	disposeLayoutMount(request) {
+		const executor = this._executor;
+		const session = this._sessions.get(request.unitId);
+		const latestStart = session === null || session === void 0 ? void 0 : session.latestStarts.get(request.mountId);
+		if ((latestStart === null || latestStart === void 0 ? void 0 : latestStart.mountEpoch) === request.mountEpoch && latestStart.viewportEpoch === request.viewportEpoch) {
+			session === null || session === void 0 || session.latestStarts.delete(request.mountId);
+			session === null || session === void 0 || session.customBlockViewportsByMount.delete(request.mountId);
+		}
+		return executor == null ? Promise.resolve() : executor.disposeLayoutMount(request);
+	}
+	dispose() {
+		const executor = this._executor;
+		if (executor != null) for (const [unitId, session] of this._sessions) {
+			this._markSessionDisposed(session);
+			executor.disposeSession({
+				unitId,
+				sessionEpoch: session.sessionEpoch
+			}).catch((error) => {
+				this._logService.error("[DocLayoutExecutorService]: failed to dispose a Worker session.", error);
+			});
+		}
+		this._sessions.clear();
+		this._executor = null;
+		this._executorReady = null;
+		this._recoveryFailure = null;
+		this._executorStatus$.complete();
+		this._customRangePresentationProviders.clear();
+		super.dispose();
+	}
+	_createSessionIfEligible(dataModel) {
+		if (this._executor == null || !this._isEligible(dataModel) || this._sessions.has(dataModel.getUnitId())) return;
+		this._replaceSession(dataModel).catch((error) => {
+			this._logService.error("[DocLayoutExecutorService]: failed to create a Worker session.", error);
+		});
+	}
+	_enqueueCommittedMutation(params) {
+		const executor = this._executor;
+		const dataModel = this._getEligibleModel(params.unitId);
+		if (executor == null || dataModel == null) return;
+		const session = this._sessions.get(params.unitId);
+		if (session == null) {
+			this._replaceSession(dataModel).catch((error) => {
+				this._logService.error("[DocLayoutExecutorService]: failed to snapshot a document mutation.", error);
+			});
+			return;
+		}
+		if (JSONX.isNoop(params.actions)) return;
+		const sourceMutationRevision = dataModel.getMutationRevision();
+		if (sourceMutationRevision !== session.sourceMutationRevision + 1) {
+			session.needsResnapshot = true;
+			return;
+		}
+		const baseRevision = session.modelRevision;
+		const modelRevision = baseRevision + 1;
+		session.modelRevision = modelRevision;
+		session.sourceMutationRevision = sourceMutationRevision;
+		session.pendingMutations.push({
+			baseRevision,
+			modelRevision,
+			actions: params.actions
+		});
+	}
+	async _startSynchronizedLayout(executor, session, identity, options, budgetMs) {
+		var _session$latestStarts;
+		const { unitId, mountId } = identity;
+		const startId = (((_session$latestStarts = session.latestStarts.get(mountId)) === null || _session$latestStarts === void 0 ? void 0 : _session$latestStarts.startId) ?? 0) + 1;
+		const startIdentity = {
+			startId,
+			mountEpoch: identity.mountEpoch,
+			viewportEpoch: identity.viewportEpoch
+		};
+		session.latestStarts.set(mountId, startIdentity);
+		const startTask = session.queue.then(async () => {
+			if (session.disposed || this._executor !== executor) return { status: "not-found" };
+			const currentModel = this._getEligibleModel(unitId);
+			if (currentModel == null || currentModel.getMutationRevision() !== session.sourceMutationRevision) {
+				session.needsResnapshot = true;
+				return {
+					status: "resnapshot-required",
+					modelRevision: session.workerRevision
+				};
+			}
+			if (session.latestStarts.get(mountId) !== startIdentity) return { status: "superseded" };
+			const mutations = session.pendingMutations.slice();
+			const projections = this._createLayoutProjectionPayload(session, identity, this._getRequiredModel(unitId));
+			const request = {
+				...identity,
+				metricsRevision: startId,
+				baseRevision: session.workerRevision,
+				modelRevision: session.modelRevision,
+				mutations,
+				...projections.request,
+				budgetMs,
+				...options
+			};
+			const result = await executor.startLayout(request);
+			if (result.status === "accepted") {
+				session.workerRevision = request.modelRevision;
+				session.pendingMutations.splice(0, mutations.length);
+				session.customBlockViewportsByMount.set(mountId, {
+					mountEpoch: identity.mountEpoch,
+					value: projections.customBlockViewports
+				});
+				session.customRangePresentations = projections.customRangePresentations;
+			} else session.needsResnapshot = true;
+			return result;
+		});
+		session.queue = startTask.then(() => void 0, (error) => {
+			session.needsResnapshot = true;
+			this._logService.error("[DocLayoutExecutorService]: synchronized layout start failed.", error);
+		});
+		return startTask;
+	}
+	_createLayoutProjectionPayload(session, identity, dataModel) {
+		const customBlockViewports = collectCustomBlockViewports(dataModel);
+		const previousCustomBlockViewports = session.customBlockViewportsByMount.get(identity.mountId);
+		const customRangePresentations = this._collectCustomRangePresentations(dataModel);
+		const customRangePresentationMap = toCustomRangePresentationMap(customRangePresentations);
+		const request = {};
+		if (previousCustomBlockViewports == null || previousCustomBlockViewports.mountEpoch !== identity.mountEpoch) request.customBlockViewports = customBlockViewports;
+		else {
+			const patch = createRecordPatch(previousCustomBlockViewports.value, customBlockViewports);
+			if (patch.removals.length > 0 || Object.keys(patch.upserts).length > 0) request.customBlockViewportPatch = patch;
+		}
+		if (session.customRangePresentations == null) request.customRangePresentations = customRangePresentations;
+		else {
+			const patch = createCustomRangePresentationPatch(session.customRangePresentations, customRangePresentationMap);
+			if (patch.removals.length > 0 || patch.upserts.length > 0) request.customRangePresentationPatch = patch;
+		}
+		return {
+			request,
+			customBlockViewports,
+			customRangePresentations: customRangePresentationMap
+		};
+	}
+	async _replaceSession(dataModel) {
+		const executor = this._requireExecutor();
+		const unitId = dataModel.getUnitId();
+		const previous = this._sessions.get(unitId);
+		if (previous != null) this._markSessionDisposed(previous);
+		const modelRevision = (previous === null || previous === void 0 ? void 0 : previous.modelRevision) ?? 0;
+		const session = {
+			sessionEpoch: ++this._sessionEpoch,
+			modelRevision,
+			sourceMutationRevision: dataModel.getMutationRevision(),
+			workerRevision: modelRevision,
+			pendingMutations: [],
+			latestStarts: /* @__PURE__ */ new Map(),
+			customBlockViewportsByMount: /* @__PURE__ */ new Map(),
+			customRangePresentations: null,
+			queue: Promise.resolve(),
+			needsResnapshot: false,
+			disposed: false,
+			cancelPendingCreateTask: null
+		};
+		const createTask = this._createSessionOnNextMacroTask(executor, session, dataModel);
+		session.queue = createTask;
+		this._sessions.set(unitId, session);
+		try {
+			await createTask;
+		} catch (error) {
+			session.needsResnapshot = true;
+			throw error;
+		}
+		return session;
+	}
+	_disposeSession(unitId) {
+		var _this$_executor3;
+		const session = this._sessions.get(unitId);
+		if (session == null) return;
+		this._markSessionDisposed(session);
+		this._sessions.delete(unitId);
+		this._hydrationSamples.delete(unitId);
+		(_this$_executor3 = this._executor) === null || _this$_executor3 === void 0 || _this$_executor3.disposeSession({
+			unitId,
+			sessionEpoch: session.sessionEpoch
+		}).catch((error) => {
+			this._logService.error("[DocLayoutExecutorService]: failed to dispose a Worker session.", error);
+		});
+	}
+	_getEligibleModel(unitId) {
+		const dataModel = this._univerInstanceService.getUnit(unitId, UniverInstanceType.UNIVER_DOC);
+		return dataModel != null && this._isEligible(dataModel) ? dataModel : null;
+	}
+	_getRequiredModel(unitId) {
+		const dataModel = this._getEligibleModel(unitId);
+		if (dataModel == null) throw new Error(`Eligible document model not found for Worker layout: "${unitId}".`);
+		return dataModel;
+	}
+	_collectCustomRangePresentations(dataModel) {
+		const presentations = [];
+		const providers = Array.from(this._customRangePresentationProviders).reverse();
+		if (providers.length === 0) return presentations;
+		const collectSegment = (segmentId, body) => {
+			if (body == null) return;
+			const seenRangeIds = /* @__PURE__ */ new Set();
+			for (const range of body.customRanges ?? []) {
+				if (seenRangeIds.has(range.rangeId)) continue;
+				seenRangeIds.add(range.rangeId);
+				for (const provider of providers) {
+					const presentation = provider(dataModel.getUnitId(), range, {
+						segmentId,
+						body
+					});
+					if (presentation != null) {
+						presentations.push({
+							segmentId,
+							rangeId: range.rangeId,
+							presentation: { ...presentation }
+						});
+						break;
+					}
+				}
+			}
+		};
+		collectSegment("", dataModel.getBody());
+		for (const [segmentId, headerModel] of dataModel.headerModelMap) collectSegment(segmentId, headerModel.getBody());
+		for (const [segmentId, footerModel] of dataModel.footerModelMap) collectSegment(segmentId, footerModel.getBody());
+		return presentations;
+	}
+	_isEligible(dataModel) {
+		if (isInternalEditorID(dataModel.getUnitId())) return false;
+		const flavor = dataModel.getSnapshot().documentStyle.documentFlavor;
+		return flavor === DocumentFlavor.TRADITIONAL || flavor === DocumentFlavor.MODERN;
+	}
+	_requireExecutor() {
+		if (this._executor == null) throw new Error("No document layout executor is registered.");
+		return this._executor;
+	}
+	_appendPerformanceSample(target, unitId, durationMs) {
+		const samples = target.get(unitId) ?? [];
+		samples.push(durationMs);
+		if (samples.length > _DocLayoutExecutorService._performanceSampleLimit) samples.splice(0, samples.length - _DocLayoutExecutorService._performanceSampleLimit);
+		target.set(unitId, samples);
+	}
+	_createSessionOnNextMacroTask(executor, session, dataModel) {
+		return new Promise((resolve, reject) => {
+			const cancelTask = requestImmediateMacroTask(() => {
+				session.cancelPendingCreateTask = null;
+				const unitId = dataModel.getUnitId();
+				if (session.disposed || this._executor !== executor || this._sessions.get(unitId) !== session) {
+					resolve();
+					return;
+				}
+				const executorReady = this._executorReady;
+				if (executorReady == null) {
+					resolve();
+					return;
+				}
+				executorReady.then(() => {
+					if (session.disposed || this._executor !== executor || this._sessions.get(unitId) !== session || this._getEligibleModel(unitId) !== dataModel) {
+						resolve();
+						return;
+					}
+					session.sourceMutationRevision = dataModel.getMutationRevision();
+					session.workerRevision = session.modelRevision;
+					session.pendingMutations.length = 0;
+					const request = {
+						unitId,
+						sessionEpoch: session.sessionEpoch,
+						snapshot: createDocumentLayoutSnapshot(dataModel.getSnapshot()),
+						modelRevision: session.modelRevision,
+						locale: this._localeService.getCurrentLocale(),
+						localeData: this._localeService.getLocales(),
+						direction: this._localeService.getDirection()
+					};
+					executor.createSession(request).then(resolve, reject);
+				}, reject);
+			});
+			session.cancelPendingCreateTask = () => {
+				cancelTask();
+				session.cancelPendingCreateTask = null;
+				resolve();
+			};
+		});
+	}
+	_markSessionDisposed(session) {
+		var _session$cancelPendin;
+		session.disposed = true;
+		(_session$cancelPendin = session.cancelPendingCreateTask) === null || _session$cancelPendin === void 0 || _session$cancelPendin.call(session);
+		session.cancelPendingCreateTask = null;
+	}
+	_disposeManagedSessions() {
+		for (const session of this._sessions.values()) this._markSessionDisposed(session);
+	}
+};
+_defineProperty(DocLayoutExecutorService, "_performanceSampleLimit", 2048);
+DocLayoutExecutorService = _DocLayoutExecutorService = __decorate([
+	__decorateParam(0, IUniverInstanceService),
+	__decorateParam(1, ICommandService),
+	__decorateParam(2, Inject(LocaleService)),
+	__decorateParam(3, ILogService)
+], DocLayoutExecutorService);
+
 //#endregion
 //#region src/services/doc-skeleton-manager.service.ts
 let DocSkeletonManagerService = class DocSkeletonManagerService extends RxDisposable {
-	constructor(_context, _localeService, _univerInstanceService) {
+	constructor(_context, _localeService, _univerInstanceService, _docLayoutExecutorService) {
 		super();
 		this._context = _context;
 		this._localeService = _localeService;
 		this._univerInstanceService = _univerInstanceService;
+		this._docLayoutExecutorService = _docLayoutExecutorService;
 		_defineProperty(this, "_skeleton", void 0);
 		_defineProperty(this, "_docViewModel", void 0);
 		_defineProperty(this, "_currentSkeleton$", new BehaviorSubject(null));
@@ -257,12 +904,23 @@ let DocSkeletonManagerService = class DocSkeletonManagerService extends RxDispos
 	getViewModel() {
 		return this._docViewModel;
 	}
+	getLayoutPerformanceMetrics() {
+		return this._docLayoutExecutorService.getPerformanceMetrics(this._context.unitId);
+	}
+	supportsIncrementalLayout() {
+		var _this$_context$unit$g;
+		const documentFlavor = (_this$_context$unit$g = this._context.unit.getSnapshot().documentStyle) === null || _this$_context$unit$g === void 0 ? void 0 : _this$_context$unit$g.documentFlavor;
+		return this._docLayoutExecutorService.getExecutor() != null && !isInternalEditorID(this._context.unitId) && (documentFlavor === DocumentFlavor.TRADITIONAL || documentFlavor === DocumentFlavor.MODERN);
+	}
 	recalculate() {
 		const skeleton = this._skeleton;
 		skeleton.calculate();
+		this._publishSkeleton(skeleton);
+		return skeleton;
+	}
+	_publishSkeleton(skeleton) {
 		this._currentSkeletonBefore$.next(skeleton);
 		this._currentSkeleton$.next(skeleton);
-		return skeleton;
 	}
 	_init() {
 		const documentDataModel = this._context.unit;
@@ -276,7 +934,8 @@ let DocSkeletonManagerService = class DocSkeletonManagerService extends RxDispos
 			this._context.unit = documentDataModel;
 		} else if (!this._docViewModel) this._docViewModel = this._buildDocViewModel(documentDataModel);
 		if (!this._skeleton) this._skeleton = this._buildSkeleton(this._docViewModel);
-		this.recalculate();
+		if (this.supportsIncrementalLayout()) this._publishSkeleton(this._skeleton);
+		else this.recalculate();
 		this._currentViewModel$.next(this._docViewModel);
 	}
 	_buildSkeleton(documentViewModel) {
@@ -286,7 +945,11 @@ let DocSkeletonManagerService = class DocSkeletonManagerService extends RxDispos
 		return new DocumentViewModel(documentDataModel);
 	}
 };
-DocSkeletonManagerService = __decorate([__decorateParam(1, Inject(LocaleService)), __decorateParam(2, IUniverInstanceService)], DocSkeletonManagerService);
+DocSkeletonManagerService = __decorate([
+	__decorateParam(1, Inject(LocaleService)),
+	__decorateParam(2, IUniverInstanceService),
+	__decorateParam(3, Inject(DocLayoutExecutorService))
+], DocSkeletonManagerService);
 
 //#endregion
 //#region src/services/doc-state-emit.service.ts
@@ -306,21 +969,113 @@ var DocStateEmitService = class extends RxDisposable {
 };
 
 //#endregion
-//#region src/commands/mutations/core-editing.mutation.ts
-const RichTextEditingMutationId = "doc.mutation.rich-text-editing";
+//#region src/commands/mutations/doc-structure-mutation-validation.ts
+const STRUCTURAL_BODY_FIELDS = [
+	"paragraphs",
+	"sectionBreaks",
+	"customBlocks",
+	"docxRawCustomBlocks",
+	"docxRawBlocks",
+	"docxExportExcludedRanges",
+	"tables",
+	"columnGroups",
+	"blockRanges"
+];
+const STRUCTURAL_DATA_STREAM_TOKENS = /* @__PURE__ */ new Set([
+	DataStreamTreeTokenType.PARAGRAPH,
+	DataStreamTreeTokenType.SECTION_BREAK,
+	DataStreamTreeTokenType.TABLE_START,
+	DataStreamTreeTokenType.TABLE_ROW_START,
+	DataStreamTreeTokenType.TABLE_CELL_START,
+	DataStreamTreeTokenType.TABLE_CELL_END,
+	DataStreamTreeTokenType.TABLE_ROW_END,
+	DataStreamTreeTokenType.TABLE_END,
+	DataStreamTreeTokenType.COLUMN_GROUP_START,
+	DataStreamTreeTokenType.COLUMN_START,
+	DataStreamTreeTokenType.COLUMN_END,
+	DataStreamTreeTokenType.COLUMN_GROUP_END,
+	DataStreamTreeTokenType.BLOCK_START,
+	DataStreamTreeTokenType.BLOCK_END,
+	DataStreamTreeTokenType.CUSTOM_BLOCK
+]);
+const NON_STRUCTURAL_ROOT_FIELDS = /* @__PURE__ */ new Set([
+	"disabled",
+	"documentStyle",
+	"drawings",
+	"drawingsOrder",
+	"lists",
+	"locale",
+	"resources",
+	"rev",
+	"settings",
+	"styles",
+	"tableSource",
+	"title"
+]);
+function isRecord$3(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function containsStructuralToken(dataStream) {
+	for (let index = 0; index < dataStream.length; index++) if (STRUCTURAL_DATA_STREAM_TOKENS.has(dataStream[index])) return true;
+	return false;
+}
+function isStructurePreservingBody(value) {
+	if (!isRecord$3(value)) return false;
+	const dataStream = value.dataStream;
+	if (dataStream != null && (typeof dataStream !== "string" || containsStructuralToken(dataStream))) return false;
+	return STRUCTURAL_BODY_FIELDS.every((field) => {
+		const metadata = value[field];
+		return metadata == null || Array.isArray(metadata) && metadata.length === 0;
+	});
+}
+function isStructurePreservingTextXEdit(value) {
+	if (!Array.isArray(value)) return false;
+	return value.every((action) => {
+		if (!isRecord$3(action) || typeof action.len !== "number" || !Number.isFinite(action.len)) return false;
+		if (action.t === TextXActionType.DELETE) return true;
+		if (action.t === TextXActionType.INSERT) return isStructurePreservingBody(action.body);
+		return action.t === TextXActionType.RETAIN && (action.body == null || isStructurePreservingBody(action.body));
+	});
+}
+function pathsEqual(left, right) {
+	return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+function isStructurePreservingJSONXEdit(actions, expectedPath) {
+	const cursor = JSON1.type.readCursor(actions);
+	let hasComponent = false;
+	let isStructurePreserving = true;
+	cursor.traverse(null, (component) => {
+		if (!isStructurePreserving) return;
+		const path = cursor.getPath();
+		hasComponent = true;
+		if (NON_STRUCTURAL_ROOT_FIELDS.has(String(path[0]))) return;
+		const componentKeys = Object.keys(component);
+		if (component.et !== TextX.id || componentKeys.some((key) => key !== "et" && key !== "e") || !pathsEqual(path, expectedPath)) {
+			isStructurePreserving = false;
+			return;
+		}
+		const edit = component.e;
+		isStructurePreserving = isStructurePreservingTextXEdit(edit);
+	});
+	return hasComponent && isStructurePreserving;
+}
 function getSegmentType(documentDataModel, segmentId) {
+	var _documentDataModel$ge;
 	if (!segmentId) return "body";
 	const { headers, footers } = documentDataModel.getSnapshot();
 	if (headers === null || headers === void 0 ? void 0 : headers[segmentId]) return "header";
 	if (footers === null || footers === void 0 ? void 0 : footers[segmentId]) return "footer";
+	if ((_documentDataModel$ge = documentDataModel.getSnapshot().notes) === null || _documentDataModel$ge === void 0 ? void 0 : _documentDataModel$ge[segmentId]) return "note";
 	return "body";
 }
 function assertValidDocBodyStructure(documentDataModel, segmentId) {
+	var _documentDataModel$ge2;
 	const segmentModel = documentDataModel.getSelfOrHeaderFooterModel(segmentId);
 	const body = segmentModel === null || segmentModel === void 0 ? void 0 : segmentModel.getBody();
 	if (!body) return;
 	const segmentType = getSegmentType(documentDataModel, segmentId);
-	const issues = validateDocBodyStructure(body, {
+	const note = (_documentDataModel$ge2 = documentDataModel.getSnapshot().notes) === null || _documentDataModel$ge2 === void 0 ? void 0 : _documentDataModel$ge2[segmentId];
+	const issues = note ? validateDocumentStructure({ notes: { [segmentId]: note } }) : validateDocBodyStructure(body, {
 		segmentType,
 		segmentId: segmentId || void 0
 	});
@@ -329,17 +1084,175 @@ function assertValidDocBodyStructure(documentDataModel, segmentId) {
 	const segmentLabel = segmentId ? `${segmentType} ${segmentId}` : segmentType;
 	throw new Error(`[DocStructure] ${segmentLabel}: ${detail}`);
 }
+function validateDocStructureMutation(documentDataModel, segmentId, actions, undoActions) {
+	const editPath = getRichTextEditPath(documentDataModel, segmentId);
+	const preservesStructure = isStructurePreservingJSONXEdit(actions, editPath) && isStructurePreservingJSONXEdit(undoActions, editPath);
+	let changesFootnoteStructure = false;
+	const cursor = JSON1.type.readCursor(actions);
+	cursor.traverse(null, (component) => {
+		const path = cursor.getPath();
+		if (path[0] === "notes" && (path.length <= 2 || path[2] !== "body") || path.includes("customRanges")) changesFootnoteStructure = true;
+		if (component.et === TextX.id && Array.isArray(component.e)) for (const action of component.e) {
+			const ranges = isRecord$3(action) && isRecord$3(action.body) ? action.body.customRanges : void 0;
+			if (Array.isArray(ranges) && ranges.some((range) => isRecord$3(range) && (range.rangeType === CustomRangeType.FOOTNOTE || range.rangeType === CustomRangeType.ENDNOTE))) changesFootnoteStructure = true;
+		}
+	});
+	if (changesFootnoteStructure) {
+		const issues = validateDocumentStructure(documentDataModel.getSnapshot());
+		if (issues.length > 0) throw new Error(`[DocStructure] ${issues.map((issue) => `${issue.code}@${issue.index ?? issue.segmentId ?? ""}`).join(", ")}`);
+	} else if (!preservesStructure) assertValidDocBodyStructure(documentDataModel, segmentId);
+	return preservesStructure && !changesFootnoteStructure;
+}
+
+//#endregion
+//#region src/commands/mutations/core-editing.mutation.ts
+let DocHistoryAction = /* @__PURE__ */ function(DocHistoryAction) {
+	DocHistoryAction["DeleteChart"] = "delete-chart";
+	DocHistoryAction["DeleteDivider"] = "delete-divider";
+	DocHistoryAction["DeleteImage"] = "delete-image";
+	DocHistoryAction["DeleteShape"] = "delete-shape";
+	DocHistoryAction["EditTableCell"] = "edit-table-cell";
+	DocHistoryAction["FormatParagraph"] = "format-paragraph";
+	DocHistoryAction["InsertCustomRange"] = "insert-custom-range";
+	DocHistoryAction["UpdateImage"] = "update-image";
+	DocHistoryAction["UpdatePageLayout"] = "update-page-layout";
+	return DocHistoryAction;
+}({});
+function extractDocumentBodyActions(actions, segmentId) {
+	if (!Array.isArray(actions)) return;
+	const bodyActions = actions.indexOf("body") > -1 ? actions : actions.find((action) => Array.isArray(action) && action.indexOf("body") > -1);
+	if (!Array.isArray(bodyActions)) return;
+	const bodyIndex = bodyActions.indexOf("body");
+	if (bodyIndex === -1) return;
+	return (bodyIndex === 0 ? "" : bodyActions[bodyIndex - 1]) === segmentId ? bodyActions.slice(bodyIndex) : void 0;
+}
+/**
+* Transforms document selections through the same JSONX actions applied by a rich-text mutation.
+* Collaboration and rendering use this shared offset rule so the Main interaction window follows
+* the transformed local caret before an authoritative background layout is published.
+*/
+function transformDocumentTextRanges(actions, textRanges, priority = "right") {
+	if (textRanges.length === 0) return [];
+	const bodyActions = extractDocumentBodyActions(actions, textRanges[0].segmentId ?? "");
+	if (bodyActions == null) return textRanges;
+	return textRanges.map((textRange) => {
+		const startOffset = JSONX.transformPosition(bodyActions, textRange.startOffset, priority);
+		const endOffset = JSONX.transformPosition(bodyActions, textRange.endOffset, priority);
+		return {
+			...textRange,
+			startOffset,
+			endOffset,
+			collapsed: startOffset === endOffset
+		};
+	});
+}
+function canRemoveFootnoteReference(actions, references) {
+	let canRemove = false;
+	const cursor = JSON1.type.readCursor(actions);
+	cursor.traverse(null, (component) => {
+		const path = cursor.getPath();
+		if (path.length === 0) canRemove = true;
+		if (canRemove || path[0] !== "body") return;
+		if (path.length === 1 && component.et === TextX.id && Array.isArray(component.e)) {
+			let offset = 0;
+			for (const action of component.e) {
+				var _action$body;
+				if (action.t === TextXActionType.DELETE && references.some((reference) => offset <= reference.endIndex && offset + action.len > reference.startIndex)) {
+					canRemove = true;
+					return;
+				}
+				if (action.t === TextXActionType.RETAIN && ((_action$body = action.body) === null || _action$body === void 0 ? void 0 : _action$body.customRanges) != null) {
+					canRemove = true;
+					return;
+				}
+				if (action.t !== TextXActionType.INSERT) offset += action.len;
+			}
+		} else if (path.length === 1 || path[1] === "customRanges" || path[1] === "dataStream") canRemove = true;
+	});
+	return canRemove;
+}
+function includeFootnoteCleanup(before, actions) {
+	var _before$body, _after$body;
+	if (!before.notes) return actions;
+	const references = ((_before$body = before.body) === null || _before$body === void 0 || (_before$body = _before$body.customRanges) === null || _before$body === void 0 ? void 0 : _before$body.filter((range) => range.rangeType === CustomRangeType.FOOTNOTE || range.rangeType === CustomRangeType.ENDNOTE)) ?? [];
+	if (references.length === 0 || !canRemoveFootnoteReference(actions, references)) return actions;
+	const after = JSONX.apply(Tools.deepClone(before), actions);
+	const remaining = new Set((_after$body = after.body) === null || _after$body === void 0 || (_after$body = _after$body.customRanges) === null || _after$body === void 0 ? void 0 : _after$body.filter((range) => range.rangeType === CustomRangeType.FOOTNOTE || range.rangeType === CustomRangeType.ENDNOTE).map((range) => {
+		var _range$properties;
+		return (_range$properties = range.properties) === null || _range$properties === void 0 ? void 0 : _range$properties.noteId;
+	}));
+	let cleanup = null;
+	const previousIds = new Set(references.map((reference) => {
+		var _reference$properties;
+		return (_reference$properties = reference.properties) === null || _reference$properties === void 0 ? void 0 : _reference$properties.noteId;
+	}));
+	for (const id of previousIds) {
+		var _after$notes;
+		if (typeof id === "string" && !remaining.has(id) && ((_after$notes = after.notes) === null || _after$notes === void 0 ? void 0 : _after$notes[id])) cleanup = JSONX.compose(cleanup, JSONX.getInstance().removeOp(["notes", id], after.notes[id]));
+	}
+	return JSONX.isNoop(cleanup) ? actions : JSONX.compose(actions, cleanup);
+}
+function applyValidatedDocumentActions(documentDataModel, segmentId, actions) {
+	const before = documentDataModel.getSnapshot();
+	const appliedActions = includeFootnoteCleanup(before, actions);
+	const undoActions = JSONX.invertWithDoc(appliedActions, before);
+	documentDataModel.apply(appliedActions);
+	try {
+		return {
+			actions: appliedActions,
+			undoActions,
+			preservesStructure: validateDocStructureMutation(documentDataModel, segmentId, appliedActions, undoActions)
+		};
+	} catch (error) {
+		documentDataModel.apply(undoActions);
+		throw error;
+	}
+}
+function resetDocumentViewModel(documentViewModel, documentDataModel, segmentId, actions, preservesStructure) {
+	var _documentViewModel$re, _documentViewModel$re2;
+	if (documentViewModel == null) return;
+	if (!(segmentId === "" && preservesStructure && (((_documentViewModel$re = documentViewModel.resetByValidatedTextMutation) === null || _documentViewModel$re === void 0 ? void 0 : _documentViewModel$re.call(documentViewModel, documentDataModel, actions)) || ((_documentViewModel$re2 = documentViewModel.resetByValidatedMetadataMutation) === null || _documentViewModel$re2 === void 0 ? void 0 : _documentViewModel$re2.call(documentViewModel, documentDataModel, actions))))) documentViewModel.reset(documentDataModel);
+}
+function scheduleDocumentSelectionUpdate(selectionManager, params, isSync) {
+	const { unitId, textRanges, trigger, noNeedSetTextRange, isEditing = true } = params;
+	if (noNeedSetTextRange || textRanges == null || textRanges.length === 0 || trigger == null || isSync) return;
+	const selectionTarget = {
+		unitId,
+		subUnitId: unitId
+	};
+	const currentSelection = selectionManager.getSelectionInfo(selectionTarget);
+	const logicalTextRanges = textRanges.map((textRange, index) => ({
+		...textRange,
+		segmentId: textRange.segmentId ?? params.segmentId ?? "",
+		collapsed: textRange.startOffset === textRange.endOffset,
+		isActive: index === textRanges.length - 1
+	}));
+	if (currentSelection != null) selectionManager.replaceSelectionInfoWithoutRefresh({
+		...currentSelection,
+		segmentId: logicalTextRanges[logicalTextRanges.length - 1].segmentId,
+		textRanges: logicalTextRanges,
+		rectRanges: [],
+		isEditing,
+		options: params.options
+	}, selectionTarget);
+	const updatedSelection = selectionManager.getSelectionInfo(selectionTarget);
+	queueMicrotask(() => {
+		if (selectionManager.getSelectionInfo(selectionTarget) !== updatedSelection) return;
+		if (updatedSelection == null) selectionManager.replaceDocRanges(logicalTextRanges, selectionTarget, isEditing, params.options);
+		else selectionManager.refreshSelection(selectionTarget, isEditing);
+	});
+}
 /**
 * The core mutator to change rich text actions. The execution result would be undo mutation params. Could be directly
 * send to undo redo service (will be used by the triggering command).
 */
 const RichTextEditingMutation = {
-	id: RichTextEditingMutationId,
+	id: RICH_TEXT_EDITING_MUTATION_ID,
 	type: CommandType.MUTATION,
 	handler: (accessor, params, options) => {
 		var _renderManagerService;
-		const { unitId, segmentId = "", actions, textRanges, prevTextRanges, trigger, noHistory, isCompositionEnd, noNeedSetTextRange, debounce, isEditing = true, isSync: paramsIsSync, syncer } = params;
-		const isSync = paramsIsSync || (options === null || options === void 0 ? void 0 : options.fromCollab) || (options === null || options === void 0 ? void 0 : options.fromChangeset);
+		const { unitId, segmentId = "", actions, textRanges, prevTextRanges, trigger, noHistory, isCompositionEnd, debounce, isEditing = true, isSync: paramsIsSync, syncer } = params;
+		const isSync = Boolean(paramsIsSync || (options === null || options === void 0 ? void 0 : options.fromCollab) || (options === null || options === void 0 ? void 0 : options.fromChangeset));
 		const univerInstanceService = accessor.get(IUniverInstanceService);
 		const renderManagerService = accessor.get(IRenderManagerService);
 		const docStateEmitService = accessor.get(DocStateEmitService);
@@ -348,41 +1261,35 @@ const RichTextEditingMutation = {
 		if (documentDataModel == null) throw new Error(`DocumentDataModel not found for unitId: ${unitId}`);
 		const docSelectionManagerService = accessor.get(DocSelectionManagerService);
 		const docRanges = docSelectionManagerService.getDocRanges() ?? [];
+		const selectionInfo = docSelectionManagerService.getSelectionInfo();
 		const disabled = !!documentDataModel.getSnapshot().disabled;
 		if (JSONX.isNoop(actions) || actions && actions.length === 0 || disabled) return {
 			unitId,
 			actions: [],
 			textRanges: docRanges
 		};
-		const undoActions = JSONX.invertWithDoc(actions, documentDataModel.getSnapshot());
-		documentDataModel.apply(actions);
-		try {
-			assertValidDocBodyStructure(documentDataModel, segmentId);
-		} catch (error) {
-			documentDataModel.apply(undoActions);
-			throw error;
-		}
-		documentViewModel === null || documentViewModel === void 0 || documentViewModel.reset(documentDataModel);
-		if (!noNeedSetTextRange && textRanges && trigger != null && !isSync) queueMicrotask(() => {
-			docSelectionManagerService.replaceDocRanges(textRanges, {
-				unitId,
-				subUnitId: unitId
-			}, isEditing, params.options);
-		});
+		const { actions: appliedActions, undoActions, preservesStructure } = applyValidatedDocumentActions(documentDataModel, segmentId, actions);
+		params.actions = appliedActions;
+		resetDocumentViewModel(documentViewModel, documentDataModel, segmentId, appliedActions, preservesStructure);
+		scheduleDocumentSelectionUpdate(docSelectionManagerService, params, isSync);
 		const changeState = {
-			commandId: RichTextEditingMutationId,
+			commandId: RICH_TEXT_EDITING_MUTATION_ID,
 			unitId,
 			segmentId,
 			trigger,
 			noHistory,
 			debounce,
 			redoState: {
-				actions,
-				textRanges
+				actions: appliedActions,
+				textRanges,
+				options: params.options,
+				isEditing
 			},
 			undoState: {
 				actions: undoActions,
-				textRanges: prevTextRanges ?? docRanges
+				textRanges: prevTextRanges ?? docRanges,
+				options: selectionInfo === null || selectionInfo === void 0 ? void 0 : selectionInfo.options,
+				isEditing: selectionInfo === null || selectionInfo === void 0 ? void 0 : selectionInfo.isEditing
 			},
 			isCompositionEnd,
 			isSync,
@@ -408,59 +1315,63 @@ const InsertTextCommand = {
 	handler: (accessor, params) => {
 		var _docDataModel$getSelf;
 		const commandService = accessor.get(ICommandService);
-		const { range, segmentId, body, unitId, cursorOffset } = params;
+		const { range, segmentId, body, unitId, cursorOffset, debounce = true, textRanges, noNeedSetTextRange, isEditing } = params;
 		const docSelectionManagerService = accessor.get(DocSelectionManagerService);
 		const docDataModel = accessor.get(IUniverInstanceService).getUnit(unitId, UniverInstanceType.UNIVER_DOC);
 		if (docDataModel == null) return false;
 		const activeRange = docSelectionManagerService.getActiveTextRange();
-		const rangeSegmentId = "segmentId" in range ? range.segmentId : void 0;
+		const rangeSegmentId = "segmentId" in range && typeof range.segmentId === "string" ? range.segmentId : void 0;
 		const targetSegmentId = segmentId ?? rangeSegmentId ?? (activeRange === null || activeRange === void 0 ? void 0 : activeRange.segmentId) ?? "";
 		const originBody = (_docDataModel$getSelf = docDataModel.getSelfOrHeaderFooterModel(targetSegmentId)) === null || _docDataModel$getSelf === void 0 ? void 0 : _docDataModel$getSelf.getBody();
 		if (originBody == null) return false;
 		const { startOffset, collapsed } = range;
 		const cursorMove = cursorOffset ?? body.dataStream.length;
-		const textRanges = [{
+		const mutationTextRanges = textRanges ?? [{
 			startOffset: startOffset + cursorMove,
 			endOffset: startOffset + cursorMove,
-			style: activeRange === null || activeRange === void 0 ? void 0 : activeRange.style,
 			collapsed
 		}];
 		const doMutation = {
 			id: RichTextEditingMutation.id,
 			params: {
 				unitId,
+				segmentId: targetSegmentId,
 				actions: [],
-				textRanges,
-				debounce: true
+				textRanges: mutationTextRanges,
+				debounce,
+				noNeedSetTextRange,
+				isEditing
 			}
 		};
-		const textX = new TextX();
-		const jsonX = JSONX.getInstance();
-		if (collapsed) {
-			if (startOffset > 0) textX.push({
-				t: TextXActionType.RETAIN,
-				len: startOffset
-			});
-			textX.push({
-				t: TextXActionType.INSERT,
-				body,
-				len: body.dataStream.length
-			});
-		} else {
-			const dos = BuildTextUtils.selection.delete([range], originBody, 0, body);
-			textX.push(...dos);
-		}
-		doMutation.params.textRanges = [{
-			startOffset: startOffset + cursorMove,
-			endOffset: startOffset + cursorMove,
-			collapsed
-		}];
-		const path = getRichTextEditPath(docDataModel, segmentId);
-		doMutation.params.actions = jsonX.editOp(textX.serialize(), path);
+		doMutation.params.actions = buildInsertTextActions(docDataModel, originBody, range, body, targetSegmentId);
 		const result = commandService.syncExecuteCommand(doMutation.id, doMutation.params);
 		return Boolean(result);
 	}
 };
+function buildInsertTextActions(documentDataModel, originBody, range, insertBody, segmentId) {
+	const { startOffset, endOffset, collapsed } = range;
+	const textX = new TextX();
+	if (collapsed) {
+		if (startOffset > 0) textX.push({
+			t: TextXActionType.RETAIN,
+			len: startOffset
+		});
+		textX.push({
+			t: TextXActionType.INSERT,
+			body: insertBody,
+			len: insertBody.dataStream.length
+		});
+	} else textX.push(...BuildTextUtils.selection.delete([range], originBody, 0, insertBody));
+	const textActions = JSONX.getInstance().editOp(textX.serialize(), getRichTextEditPath(documentDataModel, segmentId));
+	return collapsed ? textActions : appendRemovedDrawingActions(textActions, documentDataModel, originBody, startOffset, endOffset, segmentId);
+}
+function appendRemovedDrawingActions(textActions, documentDataModel, body, startOffset, endOffset, segmentId) {
+	return [textActions, ...BuildTextUtils.drawing.remove(documentDataModel.getSnapshot(), [{
+		startOffset,
+		endOffset,
+		collapsed: false
+	}], body, segmentId)].reduce((accumulator, action) => JSONX.compose(accumulator, action));
+}
 /**
 * The command to delete text, mainly used in BACKSPACE and DELETE when collapsed is true. ONLY handle collapsed range!!!
 */
@@ -487,6 +1398,7 @@ const DeleteTextCommand = {
 			id: RichTextEditingMutation.id,
 			params: {
 				unitId,
+				segmentId,
 				actions: [],
 				textRanges: [{
 					startOffset: start,
@@ -505,7 +1417,7 @@ const DeleteTextCommand = {
 			collapsed: false
 		}], body));
 		const path = getRichTextEditPath(docDataModel, segmentId);
-		doMutation.params.actions = jsonX.editOp(textX.serialize(), path);
+		doMutation.params.actions = appendRemovedDrawingActions(jsonX.editOp(textX.serialize(), path), docDataModel, body, start, end + 1, segmentId);
 		const result = commandService.syncExecuteCommand(doMutation.id, doMutation.params);
 		return Boolean(result);
 	}
@@ -785,14 +1697,243 @@ const SetDocumentNameCommand = {
 };
 
 //#endregion
-//#region src/utils/sections.ts
-/** Returns document-level section breaks, excluding table-cell and modern-column sentinels. */
-function getTopLevelSectionBreaks(body) {
-	const sectionBreakByIndex = new Map((body.sectionBreaks ?? []).map((sectionBreak) => [sectionBreak.startIndex, sectionBreak]));
-	const result = [];
-	let tableCellDepth = 0;
-	let columnDepth = 0;
-	for (let index = 0; index < body.dataStream.length; index++) {
+//#region src/services/permission/permission-point/document/comment.ts
+var DocumentCommentPermission = class {
+	constructor(unitId) {
+		this.unitId = unitId;
+		_defineProperty(this, "type", UnitObject.Document);
+		_defineProperty(this, "subType", UnitAction.Comment);
+		_defineProperty(this, "status", PermissionStatus.INIT);
+		_defineProperty(this, "id", void 0);
+		_defineProperty(this, "value", true);
+		this.id = `${this.type}.${this.subType}_${unitId}`;
+	}
+};
+
+//#endregion
+//#region src/services/permission/permission-point/document/copy.ts
+var DocumentCopyPermission = class {
+	constructor(unitId) {
+		this.unitId = unitId;
+		_defineProperty(this, "type", UnitObject.Document);
+		_defineProperty(this, "subType", UnitAction.Copy);
+		_defineProperty(this, "status", PermissionStatus.INIT);
+		_defineProperty(this, "id", void 0);
+		_defineProperty(this, "value", true);
+		this.id = `${this.type}.${this.subType}_${unitId}`;
+	}
+};
+
+//#endregion
+//#region src/services/permission/permission-point/document/editable.ts
+var DocumentEditablePermission = class {
+	constructor(unitId) {
+		this.unitId = unitId;
+		_defineProperty(this, "type", UnitObject.Document);
+		_defineProperty(this, "subType", UnitAction.Edit);
+		_defineProperty(this, "status", PermissionStatus.INIT);
+		_defineProperty(this, "id", void 0);
+		_defineProperty(this, "value", true);
+		this.id = `${this.type}.${this.subType}_${unitId}`;
+	}
+};
+
+//#endregion
+//#region src/services/permission/permission-point/document/export.ts
+var DocumentExportPermission = class {
+	constructor(unitId) {
+		this.unitId = unitId;
+		_defineProperty(this, "type", UnitObject.Document);
+		_defineProperty(this, "subType", UnitAction.Export);
+		_defineProperty(this, "status", PermissionStatus.INIT);
+		_defineProperty(this, "id", void 0);
+		_defineProperty(this, "value", true);
+		this.id = `${this.type}.${this.subType}_${unitId}`;
+	}
+};
+
+//#endregion
+//#region src/services/permission/permission-point/document/print.ts
+var DocumentPrintPermission = class {
+	constructor(unitId) {
+		this.unitId = unitId;
+		_defineProperty(this, "type", UnitObject.Document);
+		_defineProperty(this, "subType", UnitAction.Print);
+		_defineProperty(this, "status", PermissionStatus.INIT);
+		_defineProperty(this, "id", void 0);
+		_defineProperty(this, "value", true);
+		this.id = `${this.type}.${this.subType}_${unitId}`;
+	}
+};
+
+//#endregion
+//#region src/services/permission/permission-point/entity/edit.ts
+var DocumentEntityEditPermission = class {
+	constructor(unitId, objectId) {
+		this.unitId = unitId;
+		this.objectId = objectId;
+		_defineProperty(this, "type", UnitObject.DocumentEntity);
+		_defineProperty(this, "subType", UnitAction.Edit);
+		_defineProperty(this, "status", PermissionStatus.INIT);
+		_defineProperty(this, "id", void 0);
+		_defineProperty(this, "value", true);
+		this.id = `${this.type}.${this.subType}_${unitId}_${objectId}`;
+	}
+};
+
+//#endregion
+//#region src/services/permission/permission-point/paragraph/edit.ts
+var DocumentParagraphEditPermission = class {
+	constructor(unitId, objectId) {
+		this.unitId = unitId;
+		this.objectId = objectId;
+		_defineProperty(this, "type", UnitObject.DocumentParagraph);
+		_defineProperty(this, "subType", UnitAction.Edit);
+		_defineProperty(this, "status", PermissionStatus.INIT);
+		_defineProperty(this, "id", void 0);
+		_defineProperty(this, "value", true);
+		this.id = `${this.type}.${this.subType}_${unitId}_${objectId}`;
+	}
+};
+
+//#endregion
+//#region src/services/permission/permission-point/section/edit.ts
+var DocumentSectionEditPermission = class {
+	constructor(unitId, objectId) {
+		this.unitId = unitId;
+		this.objectId = objectId;
+		_defineProperty(this, "type", UnitObject.DocumentSection);
+		_defineProperty(this, "subType", UnitAction.Edit);
+		_defineProperty(this, "status", PermissionStatus.INIT);
+		_defineProperty(this, "id", void 0);
+		_defineProperty(this, "value", true);
+		this.id = `${this.type}.${this.subType}_${unitId}_${objectId}`;
+	}
+};
+
+//#endregion
+//#region src/services/permission/document-permission.ts
+const DOCUMENT_UNIT_PERMISSION_ACTIONS = [
+	UnitAction.Edit,
+	UnitAction.Copy,
+	UnitAction.Print,
+	UnitAction.Export,
+	UnitAction.Comment
+];
+const DOCUMENT_PERMISSION_OBJECT_TYPES = /* @__PURE__ */ new Set([
+	UnitObject.Document,
+	UnitObject.DocumentSection,
+	UnitObject.DocumentParagraph,
+	UnitObject.DocumentEntity
+]);
+const DOCUMENT_SECTION_PERMISSION_OBJECT_PREFIX = "section/";
+const DOCUMENT_PARAGRAPH_PERMISSION_OBJECT_PREFIX = "paragraph/";
+const DOCUMENT_ENTITY_PERMISSION_OBJECT_PREFIX = "entity/";
+function getDocumentSectionPermissionObjectId(segmentId, sectionId) {
+	return `${DOCUMENT_SECTION_PERMISSION_OBJECT_PREFIX}${encodeURIComponent(segmentId)}/${encodeURIComponent(sectionId)}`;
+}
+function getDocumentParagraphPermissionObjectId(segmentId, paragraphId) {
+	return `${DOCUMENT_PARAGRAPH_PERMISSION_OBJECT_PREFIX}${encodeURIComponent(segmentId)}/${encodeURIComponent(paragraphId)}`;
+}
+function getDocumentEntityPermissionObjectId(segmentId, entityType, entityId) {
+	return `${DOCUMENT_ENTITY_PERMISSION_OBJECT_PREFIX}${encodeURIComponent(segmentId)}/${encodeURIComponent(entityType)}/${encodeURIComponent(entityId)}`;
+}
+function createDocumentPermissionPoint(unitId, objectId, action) {
+	if (objectId === unitId) switch (action) {
+		case UnitAction.Edit: return new DocumentEditablePermission(unitId);
+		case UnitAction.Copy: return new DocumentCopyPermission(unitId);
+		case UnitAction.Print: return new DocumentPrintPermission(unitId);
+		case UnitAction.Export: return new DocumentExportPermission(unitId);
+		case UnitAction.Comment: return new DocumentCommentPermission(unitId);
+		default: throw new Error(`Unsupported Document permission action: ${action}`);
+	}
+	if (action !== UnitAction.Edit) throw new Error(`Document object permissions only support Edit: ${objectId}`);
+	if (objectId.startsWith(DOCUMENT_SECTION_PERMISSION_OBJECT_PREFIX)) return new DocumentSectionEditPermission(unitId, objectId);
+	if (objectId.startsWith(DOCUMENT_PARAGRAPH_PERMISSION_OBJECT_PREFIX)) return new DocumentParagraphEditPermission(unitId, objectId);
+	if (objectId.startsWith(DOCUMENT_ENTITY_PERMISSION_OBJECT_PREFIX)) return new DocumentEntityEditPermission(unitId, objectId);
+	throw new Error(`Unsupported Document permission object: ${objectId}`);
+}
+function getDocumentPermissionValue(permissionService, unitId, objectId, action) {
+	var _permissionService$ge;
+	return ((_permissionService$ge = permissionService.getPermissionPoint(createDocumentPermissionPoint(unitId, objectId, action).id)) === null || _permissionService$ge === void 0 ? void 0 : _permissionService$ge.value) ?? true;
+}
+function setDocumentPermissionValue(permissionService, unitId, objectId, action, value) {
+	const point = createDocumentPermissionPoint(unitId, objectId, action);
+	if (!permissionService.getPermissionPoint(point.id)) permissionService.addPermissionPoint(point);
+	permissionService.updatePermissionPoint(point.id, value);
+}
+function clearDocumentPermissionValuesForUnit(permissionService, unitId) {
+	permissionService.getAllPermissionPoint().forEach((point$, id) => {
+		point$.subscribe((point) => {
+			if (DOCUMENT_PERMISSION_OBJECT_TYPES.has(point.type) && "unitId" in point && point.unitId === unitId) permissionService.deletePermissionPoint(id);
+		}).unsubscribe();
+	});
+}
+function canEditDocumentTargets(permissionService, unitId, objectIds) {
+	if (!getDocumentPermissionValue(permissionService, unitId, unitId, UnitAction.Edit)) return false;
+	for (const objectId of objectIds) if (!getDocumentPermissionValue(permissionService, unitId, objectId, UnitAction.Edit)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/commands/commands/set-document-permission.command.ts
+const SetDocumentPermissionCommand = {
+	type: CommandType.COMMAND,
+	id: "doc.command.set-permission",
+	async handler(accessor, params) {
+		if (!params || !DOCUMENT_UNIT_PERMISSION_ACTIONS.includes(params.action)) return false;
+		if (params.objectId !== params.unitId && params.action !== UnitAction.Edit) return false;
+		if (params.policy && (![
+			"all",
+			"owner",
+			"members"
+		].includes(params.policy.edit) || params.policy.strategies.some((strategy) => !DOCUMENT_UNIT_PERMISSION_ACTIONS.includes(strategy.action) || params.objectId !== params.unitId && strategy.action !== UnitAction.Edit))) return false;
+		const point = createDocumentPermissionPoint(params.unitId, params.objectId, params.action);
+		const target = {
+			unitId: params.unitId,
+			objectId: params.objectId,
+			objectType: point.type
+		};
+		const service = accessor.get(ObjectPermissionService);
+		if (params.remove) await service.remove(target);
+		else if (params.policy) await service.save(target, params.policy);
+		else await service.setPoint(target, point, params.value);
+		return true;
+	}
+};
+
+//#endregion
+//#region src/commands/commands/set-document-permissions.command.ts
+const SetDocumentPermissionsCommand = {
+	type: CommandType.COMMAND,
+	id: "doc.command.set-permissions",
+	async handler(accessor, params) {
+		if (!(params === null || params === void 0 ? void 0 : params.unitId) || !Array.isArray(params.changes) || !params.changes.length || params.changes.some((change) => !(change === null || change === void 0 ? void 0 : change.objectId) || change.objectId === params.unitId || change.policy !== null && (!change.policy || ![
+			"all",
+			"owner",
+			"members"
+		].includes(change.policy.edit) || !Array.isArray(change.policy.collaborators) || !Array.isArray(change.policy.strategies) || change.policy.strategies.some((strategy) => strategy.action !== UnitAction.Edit)))) throw new Error("Invalid object permission batch.");
+		return accessor.get(ObjectPermissionService).saveMany(params.changes.map((change) => {
+			const point = createDocumentPermissionPoint(params.unitId, change.objectId, UnitAction.Edit);
+			return {
+				unitId: params.unitId,
+				objectId: change.objectId,
+				objectType: point.type,
+				policy: change.policy
+			};
+		}));
+	}
+};
+
+//#endregion
+//#region src/utils/sections.ts
+/** Returns document-level section breaks, excluding table-cell and modern-column sentinels. */
+function getTopLevelSectionBreaks(body) {
+	const sectionBreakByIndex = new Map((body.sectionBreaks ?? []).map((sectionBreak) => [sectionBreak.startIndex, sectionBreak]));
+	const result = [];
+	let tableCellDepth = 0;
+	let columnDepth = 0;
+	for (let index = 0; index < body.dataStream.length; index++) {
 		const token = body.dataStream[index];
 		if (token === DataStreamTreeTokenType.TABLE_CELL_START) tableCellDepth++;
 		else if (token === DataStreamTreeTokenType.TABLE_CELL_END) tableCellDepth = Math.max(0, tableCellDepth - 1);
@@ -1193,7 +2334,7 @@ const InsertDocumentColumnBreakCommand = {
 				rangeId: `docx-break-${generateRandomId()}`,
 				rangeType: CustomRangeType.CUSTOM,
 				wholeEntity: true,
-				properties: { docxBreakType: DocxBreakType.COLUMN }
+				properties: { breakType: DocxBreakType.COLUMN }
 			}]
 		});
 		return executeSectionTextX(context.commandService, context.documentDataModel, textX, InsertDocumentColumnBreakCommand.id);
@@ -1272,6 +2413,56 @@ function executeSectionTextX(commandService, documentDataModel, textX, trigger)
 	}));
 }
 
+//#endregion
+//#region src/services/permission/document-permission-rule.model.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+let DocumentPermissionRuleModel = class DocumentPermissionRuleModel extends ObjectPermissionRuleModel {
+	constructor(resources) {
+		super(resources, "DOC_OBJECT_PERMISSION_PLUGIN", UniverInstanceType.UNIVER_DOC, [
+			UnitObject.DocumentSection,
+			UnitObject.DocumentParagraph,
+			UnitObject.DocumentEntity
+		]);
+	}
+};
+DocumentPermissionRuleModel = __decorate([__decorateParam(0, IResourceManagerService)], DocumentPermissionRuleModel);
+
+//#endregion
+//#region src/commands/mutations/set-document-permission-rule.mutation.ts
+const SetDocumentPermissionRuleMutation = {
+	id: "doc.mutation.set-permission-rule",
+	type: CommandType.MUTATION,
+	handler: (accessor, params) => {
+		if (!params || !accessor.get(IUniverInstanceService).getUnit(params.unitId, UniverInstanceType.UNIVER_DOC)) return false;
+		return accessor.get(DocumentPermissionRuleModel).setRule(params.unitId, params.objectType, params.objectId, params.rule);
+	}
+};
+
+//#endregion
+//#region src/commands/mutations/set-document-permission-rules.mutation.ts
+const SetDocumentPermissionRulesMutation = {
+	id: "doc.mutation.set-permission-rules",
+	type: CommandType.MUTATION,
+	handler: (accessor, params) => {
+		if (!params || !accessor.get(IUniverInstanceService).getUnit(params.unitId, UniverInstanceType.UNIVER_DOC)) return false;
+		return accessor.get(DocumentPermissionRuleModel).setRules(params.unitId, params.rules);
+	}
+};
+
 //#endregion
 //#region src/embed-host-anchor.ts
 const EMBED_DOCS_CUSTOM_BLOCK_DEFAULT_COMPONENT_KEY = "UniverEmbedDocsCustomBlock";
@@ -1433,7 +2624,7 @@ function composeActions(actions) {
 //#endregion
 //#region package.json
 var name = "@univerjs/docs";
-var version = "1.0.0-insiders.20260809-70eefdd";
+var version = "1.0.0-rc.0";
 
 //#endregion
 //#region src/config/config.ts
@@ -1453,7 +2644,7 @@ var version = "1.0.0-insiders.20260809-70eefdd";
 * limitations under the License.
 */
 const DOCS_PLUGIN_CONFIG_KEY = "docs.config";
-const configSymbol = Symbol(DOCS_PLUGIN_CONFIG_KEY);
+const configSymbol$1 = Symbol(DOCS_PLUGIN_CONFIG_KEY);
 const defaultPluginConfig = {};
 
 //#endregion
@@ -1509,6 +2700,473 @@ DocCustomRangeController = __decorate([
 	__decorateParam(2, IUniverInstanceService)
 ], DocCustomRangeController);
 
+//#endregion
+//#region src/services/permission/document-permission-resolver.ts
+const HEADER_FOOTER_REFERENCE_KEYS = [
+	"defaultHeaderId",
+	"defaultFooterId",
+	"firstPageHeaderId",
+	"firstPageFooterId",
+	"evenPageHeaderId",
+	"evenPageFooterId"
+];
+const documentPermissionResolverIndexCache = /* @__PURE__ */ new WeakMap();
+function getDocumentPermissionResolverIndex(documentDataModel) {
+	var _getMutationRevision, _snapshot$body;
+	const mutationRevision = ((_getMutationRevision = documentDataModel.getMutationRevision) === null || _getMutationRevision === void 0 ? void 0 : _getMutationRevision.call(documentDataModel)) ?? NaN;
+	const cached = documentPermissionResolverIndexCache.get(documentDataModel);
+	if ((cached === null || cached === void 0 ? void 0 : cached.mutationRevision) === mutationRevision) return cached;
+	const snapshot = documentDataModel.getSnapshot();
+	const topLevelSections = snapshot.body ? getTopLevelSectionBreaks(snapshot.body) : [];
+	const drawingSegmentIds = /* @__PURE__ */ new Map();
+	const addDrawingSegments = (body, segmentId) => {
+		for (const block of (body === null || body === void 0 ? void 0 : body.customBlocks) ?? []) if (!drawingSegmentIds.has(block.blockId)) drawingSegmentIds.set(block.blockId, segmentId);
+	};
+	addDrawingSegments(snapshot.body, "");
+	Object.entries(snapshot.headers ?? {}).forEach(([segmentId, header]) => addDrawingSegments(header.body, segmentId));
+	Object.entries(snapshot.footers ?? {}).forEach(([segmentId, footer]) => addDrawingSegments(footer.body, segmentId));
+	Object.entries(snapshot.notes ?? {}).forEach(([segmentId, footnote]) => addDrawingSegments(footnote.body, segmentId));
+	const footnoteReferenceRanges = /* @__PURE__ */ new Map();
+	for (const reference of ((_snapshot$body = snapshot.body) === null || _snapshot$body === void 0 ? void 0 : _snapshot$body.customRanges) ?? []) {
+		var _reference$properties;
+		if ((reference.rangeType === CustomRangeType.FOOTNOTE || reference.rangeType === CustomRangeType.ENDNOTE) && typeof ((_reference$properties = reference.properties) === null || _reference$properties === void 0 ? void 0 : _reference$properties.noteId) === "string") footnoteReferenceRanges.set(reference.properties.noteId, {
+			startOffset: reference.startIndex,
+			endOffset: reference.endIndex + 1
+		});
+	}
+	const index = {
+		drawingSegmentIds,
+		footnoteReferenceRanges,
+		mutationRevision,
+		segments: /* @__PURE__ */ new Map(),
+		topLevelSections
+	};
+	documentPermissionResolverIndexCache.set(documentDataModel, index);
+	return index;
+}
+function getDocumentPermissionSegmentIndex(documentDataModel, segmentId, resolverIndex = getDocumentPermissionResolverIndex(documentDataModel)) {
+	var _documentDataModel$ge, _snapshot$notes;
+	const cached = resolverIndex.segments.get(segmentId);
+	if (cached) return cached;
+	const body = ((_documentDataModel$ge = documentDataModel.getSelfOrHeaderFooterModel(segmentId)) === null || _documentDataModel$ge === void 0 ? void 0 : _documentDataModel$ge.getBody()) ?? null;
+	const snapshot = documentDataModel.getSnapshot();
+	const note = (_snapshot$notes = snapshot.notes) === null || _snapshot$notes === void 0 ? void 0 : _snapshot$notes[segmentId];
+	const drawings = (note ? note.drawings : snapshot.drawings) ?? {};
+	const entities = body == null ? [] : [
+		...(body.tables ?? []).map((item) => ({
+			type: "table",
+			id: item.tableId,
+			startOffset: item.startIndex,
+			endOffset: item.endIndex
+		})),
+		...(body.customBlocks ?? []).map((item) => ({
+			type: drawings[item.blockId] ? "drawing" : "custom-block",
+			id: item.blockId,
+			startOffset: item.startIndex,
+			endOffset: item.startIndex + 1
+		})),
+		...(body.blockRanges ?? []).map((item) => ({
+			type: "block-range",
+			id: item.blockId,
+			startOffset: item.startIndex,
+			endOffset: item.endIndex + 1
+		})),
+		...(body.customRanges ?? []).map((item) => ({
+			type: "custom-range",
+			id: item.rangeId,
+			startOffset: item.startIndex,
+			endOffset: item.endIndex + 1
+		})),
+		...(body.columnGroups ?? []).map((item) => ({
+			type: "column-group",
+			id: item.columnGroupId,
+			startOffset: item.startIndex,
+			endOffset: item.endIndex + 1
+		}))
+	];
+	const entityRanges = new Map(entities.map((entity) => [`${entity.type}:${entity.id}`, {
+		startOffset: entity.startOffset,
+		endOffset: entity.endOffset
+	}]));
+	for (const block of (body === null || body === void 0 ? void 0 : body.customBlocks) ?? []) {
+		const range = {
+			startOffset: block.startIndex,
+			endOffset: block.startIndex + 1
+		};
+		entityRanges.set(`custom-block:${block.blockId}`, range);
+		entityRanges.set(`drawing:${block.blockId}`, range);
+	}
+	const segmentIndex = {
+		body,
+		entities,
+		entityRanges,
+		paragraphContentStartOffsets: body == null ? /* @__PURE__ */ new Map() : getParagraphContentStartOffsets(body),
+		paragraphsById: new Map(((body === null || body === void 0 ? void 0 : body.paragraphs) ?? []).filter((paragraph) => paragraph.paragraphId != null).map((paragraph) => [paragraph.paragraphId, paragraph]))
+	};
+	resolverIndex.segments.set(segmentId, segmentIndex);
+	return segmentIndex;
+}
+function getDocumentDrawingSegmentId(documentDataModel, drawingId) {
+	return getDocumentPermissionResolverIndex(documentDataModel).drawingSegmentIds.get(drawingId) ?? "";
+}
+function getDocumentEditTargetObjectIds(documentDataModel, segmentId, range) {
+	const resolverIndex = getDocumentPermissionResolverIndex(documentDataModel);
+	const segmentIndex = getDocumentPermissionSegmentIndex(documentDataModel, segmentId, resolverIndex);
+	const { body } = segmentIndex;
+	if (!body) return [];
+	return [
+		...getSectionPermissionObjectIds(documentDataModel, segmentId, range, resolverIndex),
+		...getParagraphPermissionObjectIds(body, segmentId, range, segmentIndex),
+		...getEntityPermissionObjectIds(segmentId, range, segmentIndex)
+	];
+}
+function getDocumentEditTargetObjectIdsFromActions(documentDataModel, segmentId, actions) {
+	const result = /* @__PURE__ */ new Set();
+	if (actions == null) return [];
+	const cursor = JSON1.type.readCursor(actions);
+	cursor.traverse(null, () => {
+		const path = cursor.getPath();
+		const edit = cursor.getComponent();
+		const scopedSegment = [
+			"headers",
+			"footers",
+			"notes"
+		].includes(String(path[0])) && typeof path[1] === "string" ? path[1] : segmentId;
+		if (path[0] === "notes" && typeof path[1] === "string") getSectionPermissionObjectIds(documentDataModel, path[1], {
+			startOffset: 0,
+			endOffset: 0
+		}).forEach((objectId) => result.add(objectId));
+		if (path[0] === "noteSettings") getDocumentPermissionResolverIndex(documentDataModel).topLevelSections.forEach((section) => {
+			result.add(getDocumentSectionPermissionObjectId("", section.sectionId));
+		});
+		if (path[0] === "body" && path[1] === "sectionBreaks" && typeof path[2] === "number" && (path[3] === "noteProperties" || path[3] === "suppressEndnotes")) {
+			var _documentDataModel$ge2;
+			const sectionId = (_documentDataModel$ge2 = documentDataModel.getBody()) === null || _documentDataModel$ge2 === void 0 || (_documentDataModel$ge2 = _documentDataModel$ge2.sectionBreaks) === null || _documentDataModel$ge2 === void 0 || (_documentDataModel$ge2 = _documentDataModel$ge2[path[2]]) === null || _documentDataModel$ge2 === void 0 ? void 0 : _documentDataModel$ge2.sectionId;
+			if (sectionId) result.add(getDocumentSectionPermissionObjectId("", sectionId));
+		}
+		if (path[path.length - 1] !== "body" || (edit === null || edit === void 0 ? void 0 : edit.et) !== TextX.id || !Array.isArray(edit.e) || !edit.e.every(isTextXAction)) return;
+		const textActions = edit.e;
+		let offset = 0;
+		const addRange = (startOffset, endOffset) => {
+			getDocumentEditTargetObjectIds(documentDataModel, scopedSegment, {
+				startOffset,
+				endOffset
+			}).forEach((objectId) => result.add(objectId));
+		};
+		textActions.forEach((action) => {
+			if (action.t === TextXActionType.INSERT) {
+				addRange(offset, offset);
+				return;
+			}
+			if (action.t === TextXActionType.DELETE) {
+				addRange(offset, offset + action.len);
+				offset += action.len;
+				return;
+			}
+			if (action.body !== void 0 || action.oldBody !== void 0 || action.coverType !== void 0) addRange(offset, offset + action.len);
+			offset += action.len;
+		});
+	});
+	getDrawingIdsFromActions(actions).forEach((drawingId) => {
+		var _documentDataModel$ge3, _body$customBlocks;
+		result.add(getDocumentEntityPermissionObjectId(segmentId, "drawing", drawingId));
+		const body = (_documentDataModel$ge3 = documentDataModel.getSelfOrHeaderFooterModel(segmentId)) === null || _documentDataModel$ge3 === void 0 ? void 0 : _documentDataModel$ge3.getBody();
+		const block = body === null || body === void 0 || (_body$customBlocks = body.customBlocks) === null || _body$customBlocks === void 0 ? void 0 : _body$customBlocks.find((item) => item.blockId === drawingId);
+		if (block) getSectionPermissionObjectIds(documentDataModel, segmentId, {
+			startOffset: block.startIndex,
+			endOffset: block.startIndex + 1
+		}).forEach((objectId) => result.add(objectId));
+	});
+	return [...result];
+}
+function getDrawingIdsFromActions(actions) {
+	const result = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (Array.isArray(value)) {
+			value.forEach((item, index) => {
+				if (item === "drawings" && typeof value[index + 1] === "string") result.add(value[index + 1]);
+				visit(item);
+			});
+			return;
+		}
+		if (!isRecord$2(value)) return;
+		Object.values(value).forEach(visit);
+	};
+	visit(actions);
+	return [...result];
+}
+function isTextXAction(value) {
+	if (!isRecord$2(value) || typeof value.len !== "number") return false;
+	if (value.t === TextXActionType.INSERT) return isRecord$2(value.body);
+	return value.t === TextXActionType.RETAIN || value.t === TextXActionType.DELETE;
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getDocumentEntityParentPermissionObjectIds(documentDataModel, segmentId, entityType, entityId) {
+	const resolverIndex = getDocumentPermissionResolverIndex(documentDataModel);
+	const range = getDocumentPermissionSegmentIndex(documentDataModel, segmentId, resolverIndex).entityRanges.get(`${entityType}:${entityId}`) ?? null;
+	return range ? getSectionPermissionObjectIds(documentDataModel, segmentId, range, resolverIndex) : [];
+}
+function getDocumentParagraphParentPermissionObjectIds(documentDataModel, segmentId, paragraphId) {
+	const resolverIndex = getDocumentPermissionResolverIndex(documentDataModel);
+	const segmentIndex = getDocumentPermissionSegmentIndex(documentDataModel, segmentId, resolverIndex);
+	const { body } = segmentIndex;
+	const paragraph = segmentIndex.paragraphsById.get(paragraphId);
+	if (!body || !paragraph) return [];
+	return getSectionPermissionObjectIds(documentDataModel, segmentId, {
+		startOffset: segmentIndex.paragraphContentStartOffsets.get(paragraph.startIndex) ?? getParagraphContentStartOffset(body, paragraph),
+		endOffset: paragraph.startIndex + 1
+	}, resolverIndex);
+}
+function getDocumentSectionPermissionObjectIdsByIds(sectionIds) {
+	return Array.from(sectionIds, (sectionId) => getDocumentSectionPermissionObjectId("", sectionId));
+}
+function getDocumentSectionIdsAtOffset(body, offset) {
+	return getSectionsIntersectingRange(getTopLevelSectionBreaks(body), {
+		startOffset: offset,
+		endOffset: offset
+	}).map((section) => section.sectionId);
+}
+function getSectionPermissionObjectIds(documentDataModel, segmentId, range, resolverIndex = getDocumentPermissionResolverIndex(documentDataModel)) {
+	if (segmentId) {
+		const referenceRange = resolverIndex.footnoteReferenceRanges.get(segmentId);
+		if (referenceRange) return getDocumentEditTargetObjectIds(documentDataModel, "", referenceRange);
+		return getHeaderFooterOwnerSectionIds(documentDataModel, segmentId, resolverIndex.topLevelSections).map((sectionId) => getDocumentSectionPermissionObjectId("", sectionId));
+	}
+	return getSectionsIntersectingRange(resolverIndex.topLevelSections, range).map((section) => getDocumentSectionPermissionObjectId("", section.sectionId));
+}
+function getParagraphPermissionObjectIds(body, segmentId, range, segmentIndex) {
+	const startOffset = Math.min(range.startOffset, range.endOffset);
+	const endOffset = Math.max(range.startOffset, range.endOffset);
+	return (body.paragraphs ?? []).filter((paragraph) => intersectsRange(segmentIndex.paragraphContentStartOffsets.get(paragraph.startIndex) ?? getParagraphContentStartOffset(body, paragraph), paragraph.startIndex + 1, startOffset, endOffset)).flatMap((paragraph) => paragraph.paragraphId ? [getDocumentParagraphPermissionObjectId(segmentId, paragraph.paragraphId)] : []);
+}
+function getEntityPermissionObjectIds(segmentId, range, segmentIndex) {
+	const startOffset = Math.min(range.startOffset, range.endOffset);
+	const endOffset = Math.max(range.startOffset, range.endOffset);
+	return segmentIndex.entities.filter((item) => intersectsRange(item.startOffset, item.endOffset, startOffset, endOffset)).map((item) => getDocumentEntityPermissionObjectId(segmentId, item.type, item.id));
+}
+function getSectionsIntersectingRange(sections, range) {
+	const startOffset = Math.min(range.startOffset, range.endOffset);
+	const endOffset = Math.max(range.startOffset, range.endOffset);
+	return sections.filter((section, index) => intersectsRange(index === 0 ? 0 : sections[index - 1].startIndex + 1, section.startIndex + 1, startOffset, endOffset));
+}
+function intersectsRange(targetStart, targetEnd, rangeStart, rangeEnd) {
+	if (rangeStart === rangeEnd) return rangeStart >= targetStart && rangeStart < targetEnd;
+	return rangeStart < targetEnd && rangeEnd > targetStart;
+}
+function getHeaderFooterOwnerSectionIds(documentDataModel, segmentId, sections = getDocumentPermissionResolverIndex(documentDataModel).topLevelSections) {
+	const snapshot = documentDataModel.getSnapshot();
+	const result = /* @__PURE__ */ new Set();
+	sections.forEach((section, sectionIndex) => {
+		if (HEADER_FOOTER_REFERENCE_KEYS.some((key) => resolveSectionHeaderFooterReference(snapshot.documentStyle, sections, sectionIndex, key).segmentId === segmentId)) result.add(section.sectionId);
+	});
+	return [...result];
+}
+
+//#endregion
+//#region src/controllers/doc-permission.controller.ts
+const NON_EDIT_DOCUMENT_COMMAND_IDS = /* @__PURE__ */ new Set([
+	SetDocumentPermissionCommand.id,
+	SetDocumentPermissionsCommand.id,
+	"doc.command.open-header-footer-panel",
+	"doc.command.close-header-footer",
+	"doc.command.select-all",
+	"doc.command.set-zoom-ratio"
+]);
+const DERIVED_DOCUMENT_MUTATION_IDS = /* @__PURE__ */ new Set(["docs-formula.mutation.set-last-values"]);
+let DocPermissionController = class DocPermissionController extends Disposable {
+	constructor(_injector, _commandService, _permissionService, _univerInstanceService) {
+		super();
+		this._injector = _injector;
+		this._commandService = _commandService;
+		this._permissionService = _permissionService;
+		this._univerInstanceService = _univerInstanceService;
+		this._univerInstanceService.getAllUnitsForType(UniverInstanceType.UNIVER_DOC).forEach((unit) => this._registerUnitPermissionPoints(unit.getUnitId()));
+		this.disposeWithMe(this._univerInstanceService.getTypeOfUnitAdded$(UniverInstanceType.UNIVER_DOC).subscribe(({ unit }) => this._registerUnitPermissionPoints(unit.getUnitId())));
+		this.disposeWithMe(this._commandService.beforeCommandExecuted((commandInfo, options) => {
+			this._check(commandInfo, options);
+		}));
+		this.disposeWithMe(this._univerInstanceService.getTypeOfUnitDisposed$(UniverInstanceType.UNIVER_DOC).subscribe((unit) => {
+			this._injector.get(ObjectPermissionService).clearUnit(unit.getUnitId());
+			clearDocumentPermissionValuesForUnit(this._permissionService, unit.getUnitId());
+		}));
+	}
+	_registerUnitPermissionPoints(unitId) {
+		DOCUMENT_UNIT_PERMISSION_ACTIONS.forEach((action) => {
+			const point = createDocumentPermissionPoint(unitId, unitId, action);
+			if (!this._permissionService.getPermissionPoint(point.id)) this._permissionService.addPermissionPoint(point);
+		});
+		this._injector.get(ObjectPermissionService).initializeUnit({
+			unitId,
+			objectId: unitId,
+			objectType: UnitObject.Document
+		});
+	}
+	_check(commandInfo, options) {
+		var _this$_univerInstance;
+		if ((options === null || options === void 0 ? void 0 : options.fromCollab) || (options === null || options === void 0 ? void 0 : options.fromChangeset)) return;
+		const unitAction = getDocumentUnitAction(commandInfo.id);
+		const unitId = getUnitId(commandInfo, options) ?? (unitAction ? (_this$_univerInstance = this._univerInstanceService.getCurrentUnitOfType(UniverInstanceType.UNIVER_DOC)) === null || _this$_univerInstance === void 0 ? void 0 : _this$_univerInstance.getUnitId() : void 0);
+		if (!unitId || this._univerInstanceService.getUnitType(unitId) !== UniverInstanceType.UNIVER_DOC) return;
+		if (unitAction) {
+			if (!getDocumentPermissionValue(this._permissionService, unitId, unitId, unitAction)) {
+				this._injector.get(ErrorService).emitPermissionDenied(unitId);
+				throw new CustomCommandExecutionError(`Document ${UnitAction[unitAction]} permission denied.`);
+			}
+			return;
+		}
+		const documentDataModel = this._univerInstanceService.getUnit(unitId, UniverInstanceType.UNIVER_DOC);
+		if (!documentDataModel) return;
+		const targetObjectIds = this._resolveTargetObjectIds(documentDataModel, commandInfo);
+		if (targetObjectIds === null) return;
+		if (!canEditDocumentTargets(this._permissionService, unitId, targetObjectIds)) {
+			this._injector.get(ErrorService).emitPermissionDenied(unitId, targetObjectIds);
+			throw new CustomCommandExecutionError("Document edit permission denied.");
+		}
+	}
+	_resolveTargetObjectIds(documentDataModel, commandInfo) {
+		if (commandInfo.id === RichTextEditingMutation.id) {
+			const params = commandInfo.params;
+			return getDocumentEditTargetObjectIdsFromActions(documentDataModel, params.segmentId ?? "", params.actions);
+		}
+		if (commandInfo.id === DocsRenameMutation.id) return [];
+		if (isDerivedDocumentMutation(commandInfo)) return null;
+		const knownTargets = resolveTextTargets(documentDataModel, commandInfo) ?? resolveSectionTargets(documentDataModel, commandInfo);
+		if (knownTargets) return knownTargets;
+		const entityTargets = resolveEntityTargets(documentDataModel, commandInfo);
+		if (entityTargets.length) return entityTargets;
+		return isDocumentEditCommand(commandInfo.id) || isDocumentDataMutation(commandInfo) ? [] : null;
+	}
+};
+DocPermissionController = __decorate([
+	__decorateParam(0, Inject(Injector)),
+	__decorateParam(1, ICommandService),
+	__decorateParam(2, IPermissionService),
+	__decorateParam(3, IUniverInstanceService)
+], DocPermissionController);
+function isDocumentEditCommand(id) {
+	if (NON_EDIT_DOCUMENT_COMMAND_IDS.has(id)) return false;
+	return id.startsWith("doc.command.") || id.startsWith("docs.command.") || id.startsWith("doc.command-") || id.startsWith("doc.table.");
+}
+function isDocumentDataMutation(commandInfo) {
+	const { id } = commandInfo;
+	if (isDerivedDocumentMutation(commandInfo)) return false;
+	return id.startsWith("doc.mutation.") || id.startsWith("docs.mutation.") || /^docs-[^.]+\.mutation\./.test(id);
+}
+function isDerivedDocumentMutation(commandInfo) {
+	const params = isRecord$1(commandInfo.params) ? commandInfo.params : void 0;
+	return DERIVED_DOCUMENT_MUTATION_IDS.has(commandInfo.id) || commandInfo.id === "doc.mutation.update-shape-data" && !!(params === null || params === void 0 ? void 0 : params.formulaLastValueGuard);
+}
+function resolveEntityTargets(documentDataModel, commandInfo) {
+	const params = commandInfo.params;
+	if (!isRecord$1(params)) return [];
+	const result = /* @__PURE__ */ new Set();
+	const add = (segmentId, entityType, entityId) => {
+		result.add(getDocumentEntityPermissionObjectId(segmentId, entityType, entityId));
+		getDocumentEntityParentPermissionObjectIds(documentDataModel, segmentId, entityType, entityId).forEach((objectId) => result.add(objectId));
+	};
+	collectEntityReferences(params).forEach(({ entityType, entityId }) => {
+		const explicitSegmentId = params.segmentId;
+		const segmentId = typeof explicitSegmentId === "string" ? explicitSegmentId : entityType === "drawing" || entityType === "custom-block" ? getDocumentDrawingSegmentId(documentDataModel, entityId) : "";
+		add(segmentId, entityType, entityId);
+	});
+	return [...result];
+}
+function collectEntityReferences(value) {
+	const result = /* @__PURE__ */ new Map();
+	const typeByKey = {
+		blockId: ["custom-block"],
+		drawingId: ["drawing"],
+		shapeId: ["drawing", "custom-block"],
+		tableId: ["table"],
+		rangeId: ["custom-range"],
+		columnGroupId: ["column-group"]
+	};
+	const visit = (candidate, key = "") => {
+		if (typeof candidate === "string") {
+			var _typeByKey$key;
+			(_typeByKey$key = typeByKey[key]) === null || _typeByKey$key === void 0 || _typeByKey$key.forEach((entityType) => {
+				result.set(`${entityType}\u001F${candidate}`, {
+					entityType,
+					entityId: candidate
+				});
+			});
+			return;
+		}
+		if (Array.isArray(candidate)) {
+			const singularKey = key.endsWith("Ids") ? `${key.slice(0, -3)}Id` : key;
+			candidate.forEach((item) => visit(item, singularKey));
+			return;
+		}
+		if (!isRecord$1(candidate)) return;
+		Object.entries(candidate).forEach(([childKey, child]) => visit(child, childKey));
+	};
+	visit(value);
+	return [...result.values()];
+}
+function getUnitId(commandInfo, options) {
+	const params = isRecord$1(commandInfo.params) ? commandInfo.params : void 0;
+	return typeof (params === null || params === void 0 ? void 0 : params.unitId) === "string" ? params.unitId : typeof (options === null || options === void 0 ? void 0 : options.unitId) === "string" ? options.unitId : void 0;
+}
+function getDocumentUnitAction(commandId) {
+	if (commandId === "doc.command.copy-current-paragraph" || commandId === "docs-table.command.copy-selection") return UnitAction.Copy;
+	if (commandId === "docs.operation.print") return UnitAction.Print;
+	if (commandId === "docs-exchange-client.operation.export-doc") return UnitAction.Export;
+	if (commandId === "docs.operation.start-add-comment" || commandId === "docs.operation.add-drawing-comment" || commandId.startsWith("docs.command.") && commandId.includes("comment") || commandId.startsWith("thread-comment.command.") || commandId.startsWith("thread-comment.mutation.")) return UnitAction.Comment;
+}
+function resolveTextTargets(documentDataModel, commandInfo) {
+	const { id } = commandInfo;
+	if (id === InsertTextCommand.id || id === UpdateTextCommand.id) {
+		const params = commandInfo.params;
+		return getDocumentEditTargetObjectIds(documentDataModel, params.segmentId ?? "", params.range);
+	}
+	if (id === DeleteTextCommand.id) {
+		const params = commandInfo.params;
+		const isDeleteLeft = params.direction === DeleteDirection.LEFT;
+		return getDocumentEditTargetObjectIds(documentDataModel, params.segmentId ?? "", {
+			startOffset: isDeleteLeft ? params.range.startOffset - (params.len ?? 1) : params.range.startOffset,
+			endOffset: isDeleteLeft ? params.range.startOffset : params.range.startOffset + (params.len ?? 1)
+		});
+	}
+	if (id === UpdateDocumentParagraphStyleCommand.id) {
+		const params = commandInfo.params;
+		return getDocumentEditTargetObjectIds(documentDataModel, params.segmentId ?? "", params);
+	}
+	return null;
+}
+function resolveSectionTargets(documentDataModel, commandInfo) {
+	const { id } = commandInfo;
+	if (id === UpdateDocumentSectionCommand.id) {
+		const params = commandInfo.params;
+		return getDocumentSectionPermissionObjectIdsByIds(params.updates.map((update) => update.sectionId));
+	}
+	if (id === InsertDocumentSectionBreakCommand.id || id === InsertDocumentColumnBreakCommand.id) {
+		const params = commandInfo.params;
+		const body = documentDataModel.getBody();
+		return body ? getDocumentSectionPermissionObjectIdsByIds(getDocumentSectionIdsAtOffset(body, params.offset)) : [];
+	}
+	if (id === DeleteDocumentSectionBreakCommand.id) {
+		const params = commandInfo.params;
+		const body = documentDataModel.getBody();
+		const sections = body ? getTopLevelSectionBreaks(body) : [];
+		const index = sections.findIndex((section) => section.sectionId === params.sectionId);
+		return getDocumentSectionPermissionObjectIdsByIds([params.sectionId, ...index >= 0 && index + 1 < sections.length ? [sections[index + 1].sectionId] : []]);
+	}
+	if (id === SetSectionHeaderFooterLinkCommand.id) {
+		const params = commandInfo.params;
+		return [getDocumentSectionPermissionObjectId("", params.sectionId)];
+	}
+	if (id === CreateHeaderFooterCommand.id) {
+		const params = commandInfo.params;
+		return params.sectionId ? [getDocumentSectionPermissionObjectId("", params.sectionId)] : [];
+	}
+	return null;
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 //#endregion
 //#region src/services/doc-block-move-validator.service.ts
 var DocBlockMoveValidatorService = class extends Disposable {
@@ -1604,6 +3262,9 @@ let DocStateChangeManagerService = class DocStateChangeManagerService extends Rx
 		this._historyStateCache.set(unitId, cache.history);
 		this._changeStateCache.set(unitId, cache.collaboration);
 	}
+	clearHistory(unitId) {
+		this._historyStateCache.delete(unitId);
+	}
 	_setChangeState(changeState) {
 		this._cacheChangeState(changeState, "history");
 		this._cacheChangeState(changeState, "collaboration");
@@ -1636,6 +3297,8 @@ let DocStateChangeManagerService = class DocStateChangeManagerService extends Rx
 		if (type === "history" && (trigger === RedoCommandId || trigger === UndoCommandId)) return;
 		const stateCache = type === "history" ? this._historyStateCache : this._changeStateCache;
 		const cb = type === "history" ? this._pushHistory.bind(this) : this._emitChangeState.bind(this);
+		const pendingStates = stateCache.get(unitId);
+		if ((pendingStates === null || pendingStates === void 0 ? void 0 : pendingStates.length) && pendingStates[pendingStates.length - 1].segmentId !== changeState.segmentId) cb(unitId);
 		if (stateCache.has(unitId)) {
 			const cacheStates = stateCache.get(unitId);
 			cacheStates === null || cacheStates === void 0 || cacheStates.push(changeState);
@@ -1664,12 +3327,18 @@ let DocStateChangeManagerService = class DocStateChangeManagerService extends Rx
 		const redoParams = {
 			unitId,
 			actions: cacheStates.reduce((acc, cur) => JSONX.compose(acc, cur.redoState.actions), null),
-			textRanges: lastState.redoState.textRanges
+			textRanges: lastState.redoState.textRanges,
+			segmentId: lastState.segmentId,
+			options: lastState.redoState.options,
+			isEditing: lastState.redoState.isEditing
 		};
 		const undoParams = {
 			unitId,
 			actions: cacheStates.reverse().reduce((acc, cur) => JSONX.compose(acc, cur.undoState.actions), null),
-			textRanges: firstState.undoState.textRanges
+			textRanges: firstState.undoState.textRanges,
+			segmentId: firstState.segmentId,
+			options: firstState.undoState.options,
+			isEditing: firstState.undoState.isEditing
 		};
 		undoRedoService.pushUndoRedo({
 			unitID: unitId,
@@ -1698,12 +3367,18 @@ let DocStateChangeManagerService = class DocStateChangeManagerService extends Rx
 			redoState: {
 				unitId,
 				actions: cacheStates.reduce((acc, cur) => JSONX.compose(acc, cur.redoState.actions), null),
-				textRanges: lastState.redoState.textRanges
+				textRanges: lastState.redoState.textRanges,
+				segmentId: lastState.segmentId,
+				options: lastState.redoState.options,
+				isEditing: lastState.redoState.isEditing
 			},
 			undoState: {
 				unitId,
 				actions: cacheStates.reverse().reduce((acc, cur) => JSONX.compose(acc, cur.undoState.actions), null),
-				textRanges: firstState.undoState.textRanges
+				textRanges: firstState.undoState.textRanges,
+				segmentId: firstState.segmentId,
+				options: firstState.undoState.options,
+				isEditing: firstState.undoState.isEditing
 			},
 			segmentId,
 			noHistory,
@@ -1806,6 +3481,10 @@ let UniverDocsPlugin = class UniverDocsPlugin extends Plugin {
 		this._configService.setConfig(DOCS_PLUGIN_CONFIG_KEY, rest);
 	}
 	onStarting() {
+		this._injector.add([DocumentPermissionRuleModel]);
+		this.disposeWithMe(this._injector.get(ICommandService).registerCommand(SetDocumentPermissionRuleMutation));
+		this.disposeWithMe(this._injector.get(ICommandService).registerCommand(SetDocumentPermissionRulesMutation));
+		this.disposeWithMe(this._injector.get(ObjectPermissionService).registerRuleModel(UnitObject.Document, this._injector.get(DocumentPermissionRuleModel), SetDocumentPermissionRuleMutation.id, SetDocumentPermissionRulesMutation.id));
 		this._initializeDependencies();
 		this._initializeCommands();
 	}
@@ -1815,6 +3494,8 @@ let UniverDocsPlugin = class UniverDocsPlugin extends Plugin {
 			DeleteTextCommand,
 			UpdateTextCommand,
 			CreateHeaderFooterCommand,
+			SetDocumentPermissionCommand,
+			SetDocumentPermissionsCommand,
 			SetDocumentDefaultParagraphStyleCommand,
 			SetDocumentNameCommand,
 			SetSectionHeaderFooterLinkCommand,
@@ -1837,13 +3518,16 @@ let UniverDocsPlugin = class UniverDocsPlugin extends Plugin {
 			[DocStateChangeManagerService],
 			[DocBlockMoveValidatorService],
 			[DocContentInsertService],
+			[DocLayoutExecutorService],
 			[DocTextResolverService],
-			[DocCustomRangeController]
+			[DocCustomRangeController],
+			[DocPermissionController]
 		].forEach((d) => this._injector.add(d));
 	}
 	onReady() {
 		this._injector.get(DocStateChangeManagerService);
 		this._injector.get(DocCustomRangeController);
+		this._injector.get(DocPermissionController);
 	}
 };
 _defineProperty(UniverDocsPlugin, "pluginName", "DOCS_PLUGIN");
@@ -1851,6 +3535,655 @@ _defineProperty(UniverDocsPlugin, "packageName", name);
 _defineProperty(UniverDocsPlugin, "version", version);
 UniverDocsPlugin = __decorate([__decorateParam(1, Inject(Injector)), __decorateParam(2, IConfigService)], UniverDocsPlugin);
 
+//#endregion
+//#region src/layout-worker/config/config.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+const DOCS_LAYOUT_WORKER_PLUGIN_CONFIG_KEY = "docs-layout-worker.config";
+const configSymbol = Symbol(DOCS_LAYOUT_WORKER_PLUGIN_CONFIG_KEY);
+const DEFAULT_DOCS_LAYOUT_WORKER_REQUEST_TIMEOUT_MS = 15e3;
+const defaultPluginDocsLayoutWorkerConfig = { requestTimeoutMs: DEFAULT_DOCS_LAYOUT_WORKER_REQUEST_TIMEOUT_MS };
+
+//#endregion
+//#region src/layout-worker/document-font-metrics.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+/** Collect once from the snapshot, then only from mutation payloads (including JSON1 font replacements). */
+function collectDocumentFontFamilies(value, families) {
+	if (value == null || typeof value !== "object") return;
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index++) {
+			const item = value[index];
+			if (value[index - 1] === "ff" && item != null && typeof item === "object" && typeof item.i === "string") families.add(item.i);
+			collectDocumentFontFamilies(item, families);
+		}
+		return;
+	}
+	for (const [key, item] of Object.entries(value)) if (key === "ff" && typeof item === "string") families.add(item);
+	else collectDocumentFontFamilies(item, families);
+}
+function measureDocumentFontFamilies(families) {
+	FontCache.getNormalLineHeight(getFontStyleString());
+	for (const ff of ["", ...families]) for (const bl of [BooleanNumber.FALSE, BooleanNumber.TRUE]) for (const it of [BooleanNumber.FALSE, BooleanNumber.TRUE]) FontCache.getNormalLineHeight(getFontStyleString({
+		ff,
+		bl,
+		it
+	}));
+	return FontCache.getNormalLineHeightCache();
+}
+
+//#endregion
+//#region src/layout-worker/performance-tracker.ts
+const PERFORMANCE_SAMPLE_LIMIT = 2048;
+function isRecord(value) {
+	return typeof value === "object" && value != null;
+}
+function getRequest(message) {
+	if (!isRecord(message) || typeof message.method !== "string" || !Array.isArray(message.args)) return null;
+	const request = message.args[0];
+	return isRecord(request) ? {
+		method: message.method,
+		request
+	} : null;
+}
+function getPublicationResult(message) {
+	if (!isRecord(message) || !isRecord(message.data)) return null;
+	const result = message.data;
+	if (isRecord(result.step)) return result.step;
+	return result;
+}
+function createTransferMetrics() {
+	return {
+		mutationTransferMs: [],
+		patchTransferMs: [],
+		snapshotTransferMs: []
+	};
+}
+var DocsLayoutWorkerPerformanceTracker = class {
+	constructor() {
+		_defineProperty(this, "_metrics", /* @__PURE__ */ new Map());
+	}
+	recordRequest(message, durationMs) {
+		const requestInfo = getRequest(message);
+		const unitId = requestInfo === null || requestInfo === void 0 ? void 0 : requestInfo.request.unitId;
+		if (requestInfo == null || typeof unitId !== "string") return;
+		if (requestInfo.method === "createSession") {
+			this._append(unitId, "snapshotTransferMs", durationMs);
+			return;
+		}
+		if (requestInfo.method === "startLayout" && Array.isArray(requestInfo.request.mutations) && requestInfo.request.mutations.length > 0) this._append(unitId, "mutationTransferMs", durationMs);
+	}
+	recordResponse(message, durationMs) {
+		const result = getPublicationResult(message);
+		if (result == null || typeof result.unitId !== "string" || result.publication == null) return;
+		this._append(result.unitId, "patchTransferMs", durationMs);
+	}
+	getMetrics(unitId) {
+		const metrics = this._metrics.get(unitId) ?? createTransferMetrics();
+		return {
+			mutationTransferMs: [...metrics.mutationTransferMs],
+			patchTransferMs: [...metrics.patchTransferMs],
+			snapshotTransferMs: [...metrics.snapshotTransferMs]
+		};
+	}
+	reset(unitId) {
+		this._metrics.delete(unitId);
+	}
+	resetAll() {
+		this._metrics.clear();
+	}
+	_append(unitId, metric, durationMs) {
+		const metrics = this._metrics.get(unitId) ?? createTransferMetrics();
+		const samples = metrics[metric];
+		samples.push(durationMs);
+		if (samples.length > PERFORMANCE_SAMPLE_LIMIT) samples.splice(0, samples.length - PERFORMANCE_SAMPLE_LIMIT);
+		this._metrics.set(unitId, metrics);
+	}
+};
+
+//#endregion
+//#region src/layout-worker/protocol.ts
+const DOCS_LAYOUT_WORKER_CHANNEL = "univer.docs-layout-worker";
+
+//#endregion
+//#region src/layout-worker/worker.ts
+const FONT_PROBE_CONTENT = "Univer 文档 Worker 0123456789";
+const FONT_PROBE_STYLE = "16px Arial";
+const WORKER_LAYOUT_INTERRUPT_INTERVAL = 8;
+function yieldForWorkerMessage() {
+	return new Promise((resolve) => {
+		requestImmediateMacroTask(() => resolve());
+	});
+}
+function createDocsLayoutWorkerMessageProtocol$1(performanceTracker) {
+	return {
+		send(message) {
+			const startedAt = Tools.now();
+			postMessage(message);
+			performanceTracker.recordResponse(message, Tools.now() - startedAt);
+		},
+		onMessage: new Observable((subscriber) => {
+			const handler = (event) => subscriber.next(event.data);
+			addEventListener("message", handler);
+			return () => removeEventListener("message", handler);
+		}).pipe(shareReplay({
+			bufferSize: 1,
+			refCount: true
+		}))
+	};
+}
+function getCustomRangePresentationKey(entry) {
+	return JSON.stringify([entry.segmentId, entry.rangeId]);
+}
+function applyRecordPatch(target, patch) {
+	if (patch == null) return;
+	for (const key of patch.removals) delete target[key];
+	Object.assign(target, patch.upserts);
+}
+var DocsLayoutWorkerRuntime = class {
+	constructor(_performanceTracker = new DocsLayoutWorkerPerformanceTracker()) {
+		this._performanceTracker = _performanceTracker;
+		_defineProperty(this, "_sessions", /* @__PURE__ */ new Map());
+		_defineProperty(this, "type", "worker");
+	}
+	initialize() {
+		return Promise.resolve();
+	}
+	async getCapabilities() {
+		const metrics = FontCache.getMeasureText(FONT_PROBE_CONTENT, FONT_PROBE_STYLE);
+		return {
+			protocolVersion: 5,
+			executor: "worker",
+			offscreenCanvas: typeof OffscreenCanvas !== "undefined",
+			structuredClone: typeof structuredClone === "function",
+			fontProbe: {
+				content: FONT_PROBE_CONTENT,
+				font: FONT_PROBE_STYLE,
+				width: metrics.width,
+				actualBoundingBoxAscent: metrics.actualBoundingBoxAscent,
+				actualBoundingBoxDescent: metrics.actualBoundingBoxDescent
+			}
+		};
+	}
+	async recover() {
+		for (const session of this._sessions.values()) for (const mount of session.layoutSessions.values()) mount.layoutSession.dispose();
+		this._sessions.clear();
+	}
+	async createSession(request) {
+		if (typeof OffscreenCanvas === "undefined") throw new Error("Document layout Worker requires OffscreenCanvas text measurement support.");
+		const currentSession = this._sessions.get(request.unitId);
+		if (currentSession != null && request.sessionEpoch < currentSession.sessionEpoch) return;
+		this._disposeSession(request.unitId);
+		FontCache.setNormalLineHeightCache(request.normalFontLineHeights ?? {});
+		const dataModel = new DocumentDataModel(request.snapshot);
+		const localeService = new LocaleService();
+		if (request.localeData != null) localeService.load({ [request.locale]: request.localeData });
+		localeService.setLocale(request.locale);
+		localeService.setDirection(request.direction);
+		this._sessions.set(request.unitId, {
+			sessionEpoch: request.sessionEpoch,
+			dataModel,
+			layoutSessions: /* @__PURE__ */ new Map(),
+			localeService,
+			modelRevision: request.modelRevision,
+			customRangePresentations: /* @__PURE__ */ new Map()
+		});
+	}
+	async startLayout(request) {
+		const session = this._sessions.get(request.unitId);
+		if (session == null) return { status: "not-found" };
+		if (session.modelRevision !== request.baseRevision) return {
+			status: "resnapshot-required",
+			modelRevision: session.modelRevision
+		};
+		if (!this._applyMutations(session, request)) return {
+			status: "resnapshot-required",
+			modelRevision: session.modelRevision
+		};
+		FontCache.setNormalLineHeightCache(request.normalFontLineHeights ?? {});
+		this._updateCustomRangePresentations(session, request);
+		this._applyCustomRangePresentations(session.dataModel, Array.from(session.customRangePresentations.values()));
+		let mount = session.layoutSessions.get(request.mountId);
+		if (mount != null && (request.mountEpoch < mount.mountEpoch || request.mountEpoch === mount.mountEpoch && request.viewportEpoch < mount.viewportEpoch)) return { status: "superseded" };
+		if (mount != null && request.mountEpoch > mount.mountEpoch) {
+			mount.layoutSession.dispose();
+			session.layoutSessions.delete(request.mountId);
+			mount = void 0;
+		}
+		if (mount == null) {
+			const customBlockViewports = { ...request.customBlockViewports };
+			applyRecordPatch(customBlockViewports, request.customBlockViewportPatch);
+			mount = {
+				mountId: request.mountId,
+				layoutSession: new DocumentLayoutSession(session.dataModel, session.localeService),
+				customBlockViewports,
+				metricsRevision: request.metricsRevision,
+				mountEpoch: request.mountEpoch,
+				viewportEpoch: request.viewportEpoch,
+				activeGeneration: null,
+				cancelledGeneration: null
+			};
+			session.layoutSessions.set(request.mountId, mount);
+		} else {
+			if (request.customBlockViewports != null) mount.customBlockViewports = { ...request.customBlockViewports };
+			applyRecordPatch(mount.customBlockViewports, request.customBlockViewportPatch);
+			mount.metricsRevision = request.metricsRevision;
+			mount.viewportEpoch = request.viewportEpoch;
+		}
+		const generation = mount.layoutSession.start({
+			waitForHyphenationPatterns: true,
+			reason: request.reason,
+			anchor: request.anchor,
+			priorityAnchor: request.priorityAnchor,
+			invalidation: request.invalidation
+		});
+		mount.activeGeneration = generation;
+		mount.cancelledGeneration = null;
+		return {
+			status: "accepted",
+			step: await this._runLayoutStep(session, mount, generation, request.budgetMs)
+		};
+	}
+	_applyMutations(session, request) {
+		for (const mutation of request.mutations) {
+			if (mutation.baseRevision !== session.modelRevision || mutation.modelRevision !== mutation.baseRevision + 1) return false;
+			session.dataModel.apply(mutation.actions);
+			session.modelRevision = mutation.modelRevision;
+		}
+		if (session.modelRevision !== request.modelRevision) return false;
+		if (request.mutations.length > 0) for (const mount of session.layoutSessions.values()) {
+			mount.activeGeneration = null;
+			mount.cancelledGeneration = null;
+			mount.layoutSession.resetDataModel(session.dataModel);
+		}
+		return true;
+	}
+	_applyCustomRangePresentations(dataModel, presentations) {
+		const rangeMaps = /* @__PURE__ */ new Map();
+		const segmentModels = [
+			["", dataModel],
+			...dataModel.headerModelMap,
+			...dataModel.footerModelMap
+		];
+		for (const [segmentId, segmentModel] of segmentModels) {
+			var _segmentModel$getBody;
+			const rangeMap = /* @__PURE__ */ new Map();
+			for (const range of ((_segmentModel$getBody = segmentModel.getBody()) === null || _segmentModel$getBody === void 0 ? void 0 : _segmentModel$getBody.customRanges) ?? []) {
+				const workerRange = range;
+				delete workerRange.active;
+				delete workerRange.glyphAscentEm;
+				delete workerRange.glyphDescentEm;
+				delete workerRange.glyphWidthEm;
+				delete workerRange.show;
+				if (!rangeMap.has(range.rangeId)) rangeMap.set(range.rangeId, workerRange);
+			}
+			rangeMaps.set(segmentId, rangeMap);
+		}
+		for (const { segmentId, rangeId, presentation } of presentations ?? []) {
+			const rangeMap = rangeMaps.get(segmentId);
+			const range = rangeMap === null || rangeMap === void 0 ? void 0 : rangeMap.get(rangeId);
+			if (range != null) {
+				Object.assign(range, presentation);
+				rangeMap === null || rangeMap === void 0 || rangeMap.delete(rangeId);
+			}
+		}
+	}
+	_updateCustomRangePresentations(session, request) {
+		var _request$customRangeP, _request$customRangeP2;
+		if (request.customRangePresentations != null) {
+			session.customRangePresentations.clear();
+			for (const entry of request.customRangePresentations) {
+				const key = getCustomRangePresentationKey(entry);
+				if (!session.customRangePresentations.has(key)) session.customRangePresentations.set(key, entry);
+			}
+		}
+		for (const removal of ((_request$customRangeP = request.customRangePresentationPatch) === null || _request$customRangeP === void 0 ? void 0 : _request$customRangeP.removals) ?? []) session.customRangePresentations.delete(getCustomRangePresentationKey(removal));
+		for (const entry of ((_request$customRangeP2 = request.customRangePresentationPatch) === null || _request$customRangeP2 === void 0 ? void 0 : _request$customRangeP2.upserts) ?? []) session.customRangePresentations.set(getCustomRangePresentationKey(entry), entry);
+	}
+	async stepLayout(request) {
+		const session = this._getSession(request.unitId);
+		const mount = this._getLayoutMount(session, request);
+		return await this._runLayoutStep(session, mount, request.generation, request.budgetMs);
+	}
+	async publishBacklog(request) {
+		const session = this._getSession(request.unitId);
+		const mount = this._getLayoutMount(session, request);
+		return this._runWithCustomBlockViewports(session, mount, () => ({
+			...mount.layoutSession.publishBacklog(request.generation),
+			unitId: request.unitId,
+			mountId: request.mountId,
+			mountEpoch: mount.mountEpoch,
+			viewportEpoch: mount.viewportEpoch,
+			modelRevision: session.modelRevision,
+			metricsRevision: mount.metricsRevision
+		}));
+	}
+	async getLayoutPage(request) {
+		const session = this._getSession(request.unitId);
+		const mount = this._getLayoutMount(session, request);
+		return {
+			...request,
+			modelRevision: session.modelRevision,
+			metricsRevision: mount.metricsRevision,
+			page: mount.layoutSession.getPage(request.pageIndex)
+		};
+	}
+	async cancelLayout(request) {
+		var _this$_sessions$get;
+		const mount = (_this$_sessions$get = this._sessions.get(request.unitId)) === null || _this$_sessions$get === void 0 ? void 0 : _this$_sessions$get.layoutSessions.get(request.mountId);
+		if ((mount === null || mount === void 0 ? void 0 : mount.mountEpoch) === request.mountEpoch && mount.viewportEpoch === request.viewportEpoch) {
+			if (request.generation == null || request.generation === mount.activeGeneration) mount.cancelledGeneration = request.generation ?? mount.activeGeneration;
+			mount.layoutSession.cancel(request.generation);
+		}
+	}
+	async getPerformanceMetrics(unitId) {
+		return this._performanceTracker.getMetrics(unitId);
+	}
+	async resetPerformanceMetrics(unitId) {
+		this._performanceTracker.reset(unitId);
+	}
+	async disposeLayoutMount(request) {
+		const session = this._sessions.get(request.unitId);
+		const mount = session === null || session === void 0 ? void 0 : session.layoutSessions.get(request.mountId);
+		if (session == null || mount == null || mount.mountEpoch !== request.mountEpoch || mount.viewportEpoch !== request.viewportEpoch) return;
+		session.layoutSessions.delete(request.mountId);
+		mount.activeGeneration = null;
+		mount.layoutSession.dispose();
+	}
+	async disposeSession(request) {
+		const session = this._sessions.get(request.unitId);
+		if ((session === null || session === void 0 ? void 0 : session.sessionEpoch) !== request.sessionEpoch) return;
+		this._disposeSession(request.unitId);
+		this._performanceTracker.reset(request.unitId);
+	}
+	dispose() {
+		for (const unitId of this._sessions.keys()) this._disposeSession(unitId);
+		this._performanceTracker.resetAll();
+	}
+	_getSession(unitId) {
+		const session = this._sessions.get(unitId);
+		if (session == null) throw new Error(`Document layout Worker session not found for unit "${unitId}".`);
+		return session;
+	}
+	_getLayoutMount(session, request) {
+		const mount = session.layoutSessions.get(request.mountId);
+		if (mount == null) throw new Error(`Document layout Worker mount not found: "${request.mountId}".`);
+		if (mount.mountEpoch !== request.mountEpoch || mount.viewportEpoch !== request.viewportEpoch) throw new Error(`Document layout Worker rejected a stale mount publication: "${request.mountId}".`);
+		return mount;
+	}
+	async _runLayoutStep(session, mount, generation, budgetMs) {
+		const result = this._runWithCustomBlockViewports(session, mount, () => ({
+			...mount.layoutSession.step(generation, budgetMs, WORKER_LAYOUT_INTERRUPT_INTERVAL),
+			unitId: session.dataModel.getUnitId(),
+			mountId: mount.mountId,
+			mountEpoch: mount.mountEpoch,
+			viewportEpoch: mount.viewportEpoch,
+			modelRevision: session.modelRevision,
+			metricsRevision: mount.metricsRevision
+		}));
+		await yieldForWorkerMessage();
+		if (mount.activeGeneration === generation && mount.cancelledGeneration !== generation) return result;
+		return this._runWithCustomBlockViewports(session, mount, () => ({
+			...mount.layoutSession.step(generation, 0, 1),
+			unitId: session.dataModel.getUnitId(),
+			mountId: mount.mountId,
+			mountEpoch: mount.mountEpoch,
+			viewportEpoch: mount.viewportEpoch,
+			modelRevision: session.modelRevision,
+			metricsRevision: mount.metricsRevision
+		}));
+	}
+	_runWithCustomBlockViewports(session, mount, run) {
+		const unregister = setDocsCustomBlockRenderViewportProvider((unitId, blockId) => unitId === session.dataModel.getUnitId() ? mount.customBlockViewports[blockId] : null);
+		try {
+			return run();
+		} finally {
+			unregister();
+		}
+	}
+	_disposeSession(unitId) {
+		const session = this._sessions.get(unitId);
+		if (session == null) return;
+		this._sessions.delete(unitId);
+		for (const mount of session.layoutSessions.values()) {
+			mount.activeGeneration = null;
+			mount.layoutSession.dispose();
+		}
+		session.layoutSessions.clear();
+		session.dataModel.dispose();
+		session.localeService.dispose();
+	}
+};
+function startDocsLayoutWorker() {
+	const performanceTracker = new DocsLayoutWorkerPerformanceTracker();
+	const channelService = new ChannelService(createDocsLayoutWorkerMessageProtocol$1(performanceTracker));
+	channelService.registerChannel(DOCS_LAYOUT_WORKER_CHANNEL, fromModule(new DocsLayoutWorkerRuntime(performanceTracker)));
+	return channelService;
+}
+
+//#endregion
+//#region src/layout-worker/index.ts
+const FONT_METRICS_TOLERANCE = 1;
+var DocsLayoutWorkerCapabilityError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DocsLayoutWorkerCapabilityError";
+	}
+};
+function createDocsLayoutWorkerMessageProtocol(worker, performanceTracker) {
+	return {
+		send(message) {
+			const startedAt = Tools.now();
+			worker.postMessage(message);
+			performanceTracker.recordRequest(message, Tools.now() - startedAt);
+		},
+		onMessage: new Observable((subscriber) => {
+			const handler = (event) => subscriber.next(event.data);
+			worker.addEventListener("message", handler);
+			return () => worker.removeEventListener("message", handler);
+		}).pipe(shareReplay({
+			bufferSize: 1,
+			refCount: true
+		}))
+	};
+}
+var DocsLayoutWorkerClientService = class extends Disposable {
+	constructor(_workerFactory, _requestTimeoutMs = DEFAULT_DOCS_LAYOUT_WORKER_REQUEST_TIMEOUT_MS) {
+		super();
+		this._workerFactory = _workerFactory;
+		this._requestTimeoutMs = _requestTimeoutMs;
+		_defineProperty(this, "type", "worker");
+		_defineProperty(this, "_worker", null);
+		_defineProperty(this, "_channelService", null);
+		_defineProperty(this, "_runtime", null);
+		_defineProperty(this, "_initialization", void 0);
+		_defineProperty(this, "_initialized", false);
+		_defineProperty(this, "_performanceTracker", new DocsLayoutWorkerPerformanceTracker());
+		_defineProperty(this, "_fontFamilies", /* @__PURE__ */ new Map());
+		this._initialization = this._replaceRuntime();
+	}
+	initialize() {
+		return this._initialization;
+	}
+	getCapabilities() {
+		return this._getRuntime().getCapabilities();
+	}
+	async recover() {
+		this._initialization = this._replaceRuntime();
+		await this._initialization;
+	}
+	createSession(request) {
+		const families = /* @__PURE__ */ new Set();
+		collectDocumentFontFamilies(request.snapshot, families);
+		this._fontFamilies.set(request.unitId, families);
+		const measuredRequest = {
+			...request,
+			normalFontLineHeights: measureDocumentFontFamilies(families)
+		};
+		if (this._initialized) return this._withTimeout(this._getRuntime().createSession(measuredRequest), "create session");
+		const capturedRequest = Tools.deepClone(measuredRequest);
+		return this._initialization.then(() => this._withTimeout(this._getRuntime().createSession(capturedRequest), "create session"));
+	}
+	async startLayout(request) {
+		await this._initialization;
+		const families = this._fontFamilies.get(request.unitId);
+		if (families != null) collectDocumentFontFamilies(request.mutations, families);
+		const measuredRequest = families == null ? request : {
+			...request,
+			normalFontLineHeights: measureDocumentFontFamilies(families)
+		};
+		return this._withTimeout(this._getRuntime().startLayout(measuredRequest), "start layout");
+	}
+	async stepLayout(request) {
+		await this._initialization;
+		return this._withTimeout(this._getRuntime().stepLayout(request), "step layout");
+	}
+	async publishBacklog(request) {
+		await this._initialization;
+		return this._withTimeout(this._getRuntime().publishBacklog(request), "publish layout backlog");
+	}
+	async getLayoutPage(request) {
+		await this._initialization;
+		return this._withTimeout(this._getRuntime().getLayoutPage(request), "get layout page");
+	}
+	async cancelLayout(request) {
+		await this._initialization;
+		return this._withTimeout(this._getRuntime().cancelLayout(request), "cancel layout");
+	}
+	async getPerformanceMetrics(unitId) {
+		await this._initialization;
+		const workerMetrics = await this._withTimeout(this._getRuntime().getPerformanceMetrics(unitId), "read performance metrics");
+		const clientMetrics = this._performanceTracker.getMetrics(unitId);
+		return {
+			mutationTransferMs: clientMetrics.mutationTransferMs,
+			patchTransferMs: workerMetrics.patchTransferMs,
+			snapshotTransferMs: clientMetrics.snapshotTransferMs
+		};
+	}
+	async resetPerformanceMetrics(unitId) {
+		await this._initialization;
+		await this._withTimeout(this._getRuntime().resetPerformanceMetrics(unitId), "reset performance metrics");
+		this._performanceTracker.reset(unitId);
+	}
+	async disposeLayoutMount(request) {
+		await this._initialization;
+		return this._withTimeout(this._getRuntime().disposeLayoutMount(request), "dispose layout mount");
+	}
+	async disposeSession(request) {
+		await this._initialization;
+		await this._withTimeout(this._getRuntime().disposeSession(request), "dispose session");
+		this._performanceTracker.reset(request.unitId);
+		this._fontFamilies.delete(request.unitId);
+	}
+	dispose() {
+		this._disposeRuntime();
+		super.dispose();
+	}
+	async _replaceRuntime() {
+		this._initialized = false;
+		this._disposeRuntime();
+		const worker = this._workerFactory();
+		const channelService = new ChannelService(createDocsLayoutWorkerMessageProtocol(worker, this._performanceTracker));
+		this._worker = worker;
+		this._channelService = channelService;
+		this._runtime = toModule(channelService.requestChannel(DOCS_LAYOUT_WORKER_CHANNEL));
+		await this._withTimeout(this._verifyCapabilities(), "verify capabilities");
+		this._initialized = true;
+	}
+	_disposeRuntime() {
+		var _this$_channelService, _this$_worker;
+		this._fontFamilies.clear();
+		this._initialized = false;
+		(_this$_channelService = this._channelService) === null || _this$_channelService === void 0 || _this$_channelService.dispose();
+		this._channelService = null;
+		this._runtime = null;
+		(_this$_worker = this._worker) === null || _this$_worker === void 0 || _this$_worker.terminate();
+		this._worker = null;
+		this._performanceTracker.resetAll();
+	}
+	_getRuntime() {
+		if (this._runtime == null) throw new Error("Document layout Worker runtime is unavailable.");
+		return this._runtime;
+	}
+	_withTimeout(task, operation) {
+		let timeoutId = null;
+		const timeout = new Promise((_resolve, reject) => {
+			timeoutId = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`Document layout Worker timed out while attempting to ${operation}.`));
+			}, this._requestTimeoutMs);
+		});
+		return Promise.race([task, timeout]).finally(() => {
+			if (timeoutId != null) clearTimeout(timeoutId);
+		});
+	}
+	async _verifyCapabilities() {
+		const capabilities = await this.getCapabilities();
+		if (capabilities.protocolVersion !== 5) throw new DocsLayoutWorkerCapabilityError("Document layout Worker protocol version mismatch.");
+		if (!capabilities.offscreenCanvas || !capabilities.structuredClone) throw new DocsLayoutWorkerCapabilityError("Document layout Worker requires OffscreenCanvas and structured clone support.");
+		const mainMetrics = FontCache.getMeasureText(capabilities.fontProbe.content, capabilities.fontProbe.font);
+		if ([
+			[mainMetrics.width, capabilities.fontProbe.width],
+			[mainMetrics.actualBoundingBoxAscent, capabilities.fontProbe.actualBoundingBoxAscent],
+			[mainMetrics.actualBoundingBoxDescent, capabilities.fontProbe.actualBoundingBoxDescent]
+		].some(([mainValue, workerValue]) => !Number.isFinite(mainValue) || !Number.isFinite(workerValue) || Math.abs(mainValue - workerValue) > FONT_METRICS_TOLERANCE)) throw new DocsLayoutWorkerCapabilityError("Document layout Worker font metrics differ from the main rendering context.");
+	}
+};
+let UniverDocsLayoutWorkerPlugin = class UniverDocsLayoutWorkerPlugin extends Plugin {
+	constructor(_config = defaultPluginDocsLayoutWorkerConfig, _injector, _layoutExecutorService, _configService) {
+		super();
+		this._config = _config;
+		this._injector = _injector;
+		this._layoutExecutorService = _layoutExecutorService;
+		this._configService = _configService;
+		const { ...rest } = merge({}, defaultPluginDocsLayoutWorkerConfig, this._config);
+		this._configService.setConfig(DOCS_LAYOUT_WORKER_PLUGIN_CONFIG_KEY, rest);
+	}
+	onStarting() {
+		if (typeof this._config.workerFactory !== "function") throw new TypeError("[UniverDocsLayoutWorkerPlugin]: workerFactory is required.");
+		const requestTimeoutMs = this._config.requestTimeoutMs ?? 15e3;
+		if (!Number.isFinite(requestTimeoutMs) || requestTimeoutMs <= 0) throw new RangeError("[UniverDocsLayoutWorkerPlugin]: requestTimeoutMs must be a positive finite number.");
+		const client = new DocsLayoutWorkerClientService(this._config.workerFactory, requestTimeoutMs);
+		this._injector.add([DocsLayoutWorkerClientService, { useValue: client }]);
+		this.disposeWithMe(client);
+		this.disposeWithMe(this._layoutExecutorService.register(client));
+	}
+};
+_defineProperty(UniverDocsLayoutWorkerPlugin, "pluginName", "DOCS_LAYOUT_WORKER_PLUGIN");
+_defineProperty(UniverDocsLayoutWorkerPlugin, "packageName", name);
+_defineProperty(UniverDocsLayoutWorkerPlugin, "version", version);
+UniverDocsLayoutWorkerPlugin = __decorate([
+	DependentOn(UniverDocsPlugin),
+	__decorateParam(1, Inject(Injector)),
+	__decorateParam(2, Inject(DocLayoutExecutorService)),
+	__decorateParam(3, IConfigService)
+], UniverDocsLayoutWorkerPlugin);
+
 //#endregion
 //#region src/services/doc-interceptor/interceptor-const.ts
 const CUSTOM_RANGE = createInterceptorKey("CUSTOM_RANGE");
@@ -1907,6 +4240,7 @@ let DocInterceptorService = class DocInterceptorService extends Disposable {
 				return this.fetchThroughInterceptors(DOC_INTERCEPTOR_POINT.CUSTOM_RANGE)(viewModel.getCustomRangeRaw(index), {
 					index,
 					unitId: viewModel.getDataModel().getUnitId(),
+					body: viewModel.getDataModel().getBody(),
 					customRanges: viewModel.getDataModel().getCustomRanges() ?? []
 				});
 			},
@@ -2168,4 +4502,4 @@ function normalizeTextRange(textRange) {
 }
 
 //#endregion
-export { CreateHeaderFooterCommand, DOC_INTERCEPTOR_POINT, DOC_SELECTION_OPTION_PRESERVE_CARET, DeleteDocumentSectionBreakCommand, DeleteTextCommand, DocBlockMoveValidatorService, DocContentInsertService, DocInterceptorService, DocSelectionManagerService, DocSkeletonManagerService, DocStateChangeManagerService, DocStateEmitService, DocTextResolverService, EMBED_DOCS_CUSTOM_BLOCK_DEFAULT_COMPONENT_KEY, HeaderFooterType, IDocStateChangeInterceptorService, InsertDocumentColumnBreakCommand, InsertDocumentSectionBreakCommand, InsertTextCommand, RichTextEditingMutation, SetDocumentDefaultParagraphStyleCommand, SetDocumentNameCommand, SetSectionHeaderFooterLinkCommand, SetTextSelectionsOperation, UniverDocsPlugin, UpdateDocumentParagraphStyleCommand, UpdateDocumentSectionCommand, UpdateTextCommand, addCustomRangeBySelectionFactory, addCustomRangeFactory, buildDocTransform, consumeContentInsertRange, createDocsCustomBlockDrawing, createDocsCustomBlockInsertMutation, createDocsCustomBlockRemoveMutation, createEmbedDocsCustomBlockData, createInsertCustomBlockActions, createRemoveCustomBlockActions, createSectionColumnProperties, deleteCustomRangeFactory, docDrawingPositionToTransform, generateParagraphs, getContentInsertRange, getEffectiveSectionPageSetup, getSectionContentWidth, getTopLevelSectionBreaks, isEmbedDocsCustomBlockData, isHeaderFooterSelection, isSheetLikeDocsCustomBlockChildType, normalizeTextRange, replaceSelectionFactory, resolveDocsCustomBlockSize, shouldUseInlineTextSelectionForDocsCustomBlockDrawing, transformToDocDrawingPosition };
+export { CreateHeaderFooterCommand, DOCUMENT_UNIT_PERMISSION_ACTIONS, DOC_INTERCEPTOR_POINT, DOC_SELECTION_OPTION_PRESERVE_CARET, DeleteDocumentSectionBreakCommand, DeleteTextCommand, DocBlockMoveValidatorService, DocContentInsertService, DocHistoryAction, DocInterceptorService, DocLayoutExecutorService, DocLayoutExecutorState, DocLayoutExecutorType, DocLayoutSessionStatus, DocSelectionManagerService, DocSkeletonManagerService, DocStateChangeManagerService, DocStateEmitService, DocTextResolverService, DocsLayoutWorkerCapabilityError, DocsLayoutWorkerClientService, EMBED_DOCS_CUSTOM_BLOCK_DEFAULT_COMPONENT_KEY, HeaderFooterType, IDocStateChangeInterceptorService, InsertDocumentColumnBreakCommand, InsertDocumentSectionBreakCommand, InsertTextCommand, RichTextEditingMutation, SetDocumentDefaultParagraphStyleCommand, SetDocumentNameCommand, SetDocumentPermissionCommand, SetDocumentPermissionRuleMutation, SetDocumentPermissionRulesMutation, SetDocumentPermissionsCommand, SetSectionHeaderFooterLinkCommand, SetTextSelectionsOperation, UniverDocsLayoutWorkerPlugin, UniverDocsPlugin, UpdateDocumentParagraphStyleCommand, UpdateDocumentSectionCommand, UpdateTextCommand, addCustomRangeBySelectionFactory, addCustomRangeFactory, buildDocTransform, canEditDocumentTargets, consumeContentInsertRange, createDocsCustomBlockDrawing, createDocsCustomBlockInsertMutation, createDocsCustomBlockRemoveMutation, createDocumentPermissionPoint, createEmbedDocsCustomBlockData, createInsertCustomBlockActions, createRemoveCustomBlockActions, createSectionColumnProperties, deleteCustomRangeFactory, docDrawingPositionToTransform, generateParagraphs, getContentInsertRange, getDocumentDrawingSegmentId, getDocumentEditTargetObjectIds, getDocumentEntityParentPermissionObjectIds, getDocumentEntityPermissionObjectId, getDocumentParagraphParentPermissionObjectIds, getDocumentParagraphPermissionObjectId, getDocumentPermissionValue, getDocumentSectionPermissionObjectId, getEffectiveSectionPageSetup, getSectionContentWidth, getTopLevelSectionBreaks, isEmbedDocsCustomBlockData, isHeaderFooterSelection, isSheetLikeDocsCustomBlockChildType, normalizeTextRange, replaceSelectionFactory, resolveDocsCustomBlockSize, setDocumentPermissionValue, shouldUseInlineTextSelectionForDocsCustomBlockDrawing, startDocsLayoutWorker, transformDocumentTextRanges, transformToDocDrawingPosition };