fabricjs-document-engine 0.3.0 → 0.5.0

package/README.md

@@ -11,6 +11,8 @@ Fabric already draws objects, handles interaction and serializes to JSON. This p
 - **Safe saving.** It tracks unsaved changes and can autosave. Only one save runs at a time, so a slow older save can never overwrite newer work. Revision checks catch another tab or device saving the same document, and failed saves are retried with backoff.
 - **Your storage.** Plug in any backend with two functions, or use the built-in memory and localStorage adapters. No hosted service is needed.
 - **Assets and fonts.** Documents record the images and fonts they need. When a document is opened, every image and font is checked first. You get the exact list of what is missing, can offer replacements, and tab-only images are uploaded when you save.
+- **Recovery.** Unsaved work is copied to IndexedDB while the user edits, and again at the moment the tab is closed or refreshed. After a crash or refresh you can offer to restore it, including images that only existed in the old tab.
+- **Dependable export.** PNG, JPEG, WebP, SVG and editable JSON. You choose the area, scale and background. A preflight check means an export either succeeds or tells you exactly which image or font prevents it.
 - **Reliable undo and redo.** One user action is one undo step. Transactions group several code changes into one labelled step, and ids survive undo and redo.
 - **Fabric 6 and 7.** Every release is tested against both.
 
@@ -175,6 +177,75 @@ await engine.replaceImage('/old-logo.png', '/new-logo.png');
 
 `replaceImage` swaps every image that uses a URL. Each image keeps its size on the page, and the change is one undo step. `engine.getAssetManifest()` returns the manifest for the current canvas.
 
+## Export
+
+```ts
+import { downloadExport } from 'fabricjs-document-engine';
+
+const result = await engine.export({ format: 'png', scale: 2 });
+downloadExport(result, 'poster.png');
+```
+
+`result` is `{ format, mimeType, blob, width, height, warnings }`. JSON exports also include `document`.
+
+| Option | Values | Default |
+| --- | --- | --- |
+| `format` | `'png'`, `'jpeg'`, `'webp'`, `'svg'` or `'json'` | required |
+| `scale` | Output size multiplier, such as `2` for retina | `1` |
+| `quality` | 0 to 1, for JPEG and WebP | `0.92` |
+| `area` | `'canvas'`, `'content'` (every object), `'selection'`, or `{ left, top, width, height }` | `'canvas'` |
+| `padding` | Extra space around `content` or `selection` | `0` |
+| `background` | `'keep'`, `'transparent'` or any CSS color | `'keep'` |
+| `signal` | An `AbortSignal` to cancel | |
+
+- The current zoom and pan do not matter. Exports always use document coordinates, and the view is restored afterwards.
+- A JPEG has no transparency, so an empty or transparent background becomes white instead of black.
+- The export never changes the canvas, the history or the unsaved state.
+- A JSON export is the same portable document a save produces, including uploaded images when `assets.upload` is set.
+
+### Preflight and errors
+
+Before rendering, the engine checks the objects on the canvas:
+
+- **`MISSING_IMAGE`**: an image failed to load.
+- **`CROSS_ORIGIN_IMAGE`**: an image from another site without CORS would make the browser block a PNG, JPEG or WebP export. SVG and JSON are not affected.
+- **`MISSING_FONT`**: a font is not available and `assets.requireFonts` is on. Otherwise you get a `FONT_UNAVAILABLE` warning.
+
+If any problem is found, `export` rejects with `EXPORT_BLOCKED`, and `error.problems` lists each `{ code, message, url?, family?, objectIds }`. You can run the same check first to show it in your UI:
+
+```ts
+const check = await engine.preflightExport({ format: 'png' });
+if (!check.ok) showProblems(check.problems);
+```
+
+## Recovery
+
+```ts
+import { createIndexedDbRecovery } from 'fabricjs-document-engine/recovery';
+
+const engine = createDocumentEngine({
+  canvas,
+  storage,
+  recovery: { store: createIndexedDbRecovery(), interval: 2000 },
+});
+
+const [latest] = await engine.getRecoverableDocuments();
+if (latest && confirm(`Restore unsaved work from ${new Date(latest.savedAt).toLocaleString()}?`)) {
+  await engine.restoreRecovery(latest.documentId);
+} else if (latest) {
+  await engine.discardRecovery(latest.documentId);
+}
+```
+
+- **Checkpoints.** While there are unsaved changes, a copy is written at most once every `interval` ms (default 2000). Nothing is written while the document is saved.
+- **Closing or refreshing.** Browsers do not let IndexedDB finish writing while a page unloads. So when the tab is hidden or closed, the engine also writes an immediate copy to localStorage. The newest copy wins when you read it back.
+- **Tab-only images.** Images with `blob:` URLs vanish on refresh. Checkpoints keep the image data, and restoring creates fresh URLs for it.
+- **After a save.** When a save covers every change, the copy is removed. If the tab closes during a save, the copy stays, so work is never lost between the edit and the server.
+- **Restoring.** The restored document is marked as unsaved and keeps the revision it was based on. If the server moved on meanwhile, the next save reports `SAVE_CONFLICT` instead of overwriting newer work.
+- **Interrupted loads.** A marker is kept while a document loads. If the tab crashes during loading, `engine.getInterruptedLoad()` returns `{ documentId, startedAt }` on the next start, so you can skip or discard that document instead of crashing again.
+- `engine.flushRecovery()` writes a copy right now. `engine.getRecovery(id?)` reads one.
+- `createMemoryRecovery()` keeps copies in memory, which is useful for tests. To use your own storage, implement `{ get, set, delete, keys }`, plus an optional synchronous `setNow` for the moment the page closes.
+
 ## Custom objects
 
 ```ts
@@ -282,6 +353,13 @@ Keep project data such as titles, owners and tags in `metadata` with `engine.upd
 | `engine.getAssetManifest()` | Lists the images and fonts used on the canvas. |
 | `engine.checkAssets()` | Resolves to `{ manifest, missingImages, unavailableFonts, warnings }` for the current canvas. |
 | `engine.replaceImage(oldUrl, newUrl)` | Replaces every image with that URL as one undo step. Resolves to the number of images replaced. |
+| `engine.export(options)` | Exports PNG, JPEG, WebP, SVG or JSON. See [Export](#export). |
+| `engine.preflightExport(options)` | Resolves to `{ ok, problems, warnings }` without exporting. |
+| `downloadExport(result, fileName?)` | Starts a browser download of an export result. |
+| `engine.getRecoverableDocuments()` | Lists recovery copies, newest first. |
+| `engine.restoreRecovery(id?)` / `engine.discardRecovery(id?)` | Loads or deletes a recovery copy. The default is the current document. |
+| `engine.getRecovery(id?)` / `engine.flushRecovery()` | Reads a copy, or writes one now. |
+| `engine.getInterruptedLoad()` | Returns the load that was running when the tab last crashed, if any. |
 | `engine.transaction(label, work)` | Runs `work` and records everything it changed as one undo step. Returns what `work` returns. |
 | `engine.commit(label?)` | Records changes made since the last step. Returns `false` when nothing changed. |
 | `engine.undo()` / `engine.redo()` | Resolves to `true` when a step was applied. Calls run one after another. |
@@ -289,7 +367,7 @@ Keep project data such as titles, owners and tags in `metadata` with `engine.upd
 | `engine.getHistory()` | Returns `{ undo, redo }` label lists, newest first. |
 | `engine.clearHistory()` | Forgets all steps. Loading a document or starting a new one also does this. |
 | `bindKeyboardShortcuts(engine, { target? })` | Adds the undo and redo shortcuts. Returns an unbind function. |
-| `engine.on(event, handler)` | Listens to `load:start`, `load:success`, `load:error`, `save:start`, `save:success`, `save:error`, `save:retry`, `save:status`, `assets:warning`, `history:change` or `history:error`. Returns an unsubscribe function. |
+| `engine.on(event, handler)` | Listens to `load:start`, `load:success`, `load:error`, `save:start`, `save:success`, `save:error`, `save:retry`, `save:status`, `assets:warning`, `recovery:checkpoint`, `recovery:restored`, `recovery:error`, `export:success`, `export:error`, `history:change` or `history:error`. Returns an unsubscribe function. |
 | `engine.destroy()` | Stops listening to the canvas and cancels a running load. |
 | `validateDocument(value)` | Returns a list of issues with the exact path of each problem. |
 
@@ -312,6 +390,13 @@ Every failure is a `DocumentEngineError` with a `code` you can switch on:
 | `SAVE_CANCELLED` | A queued save was dropped because another document was opened. |
 | `DOCUMENT_NOT_FOUND` | The built-in adapters have no document with that id. |
 | `HISTORY_FAILED` | Undo or redo could not rebuild an object, for example because an image is gone. The step is kept and the canvas is unchanged. |
+| `EXPORT_BLOCKED` | The preflight found problems. `error.problems` lists each one with the objects involved. |
+| `INVALID_EXPORT_OPTIONS` | The format, scale, quality, area or padding is not valid, or the area is empty. |
+| `EXPORT_ABORTED` | The export was cancelled with its `signal`. |
+| `EXPORT_FAILED` | Fabric could not render the export. `error.cause` holds the original error. |
+| `RECOVERY_MISSING` | A recovery method was called without `recovery: { store }`. |
+| `RECOVERY_NOT_FOUND` | There is no recovery copy for that document. |
+| `RECOVERY_FAILED` | Writing a recovery copy failed, for example because storage is full. It is delivered as a `recovery:error` event and never interrupts editing. |
 | `STORAGE_MISSING` | `load` or `save` was called without a storage adapter. |
 | `INVALID_CUSTOM_OBJECT` | A registered class has no static `type`, or it does not extend a Fabric class. |
 | `ENGINE_DESTROYED` | The engine was used after `destroy()`. |
@@ -326,8 +411,8 @@ A failed load never clears or half-fills your canvas.
 | 2 | Undo and redo with transactions | 0.1.0 |
 | 3 | Safe saving: dirty state, autosave, stale-response protection | 0.2.0 |
 | 4 | Assets and fonts | 0.3.0 |
-| 5 | Recovery after a refresh or crash | |
-| 6 | PNG, JPEG, SVG and JSON export with preflight checks | |
+| 5 | Recovery after a refresh or crash | 0.4.0 |
+| 6 | PNG, JPEG, SVG and JSON export with preflight checks | 0.5.0 |
 | 7 | Named versions and schema migrations | |
 | 8 | React adapter and examples | |
 | 9 | Hardening and benchmarks | |

package/dist/assets/asset-pipeline.cjs

@@ -172,3 +172,4 @@ async function prepareAssetsForSave(document, options, uploadedUrls) {
 exports.inspectAssets = inspectAssets;
 exports.prepareAssetsForLoad = prepareAssetsForLoad;
 exports.prepareAssetsForSave = prepareAssetsForSave;
+exports.rewriteUrls = rewriteUrls;

package/dist/assets/asset-pipeline.js

@@ -169,4 +169,4 @@ async function prepareAssetsForSave(document, options, uploadedUrls) {
 	};
 }
 //#endregion
-export { inspectAssets, prepareAssetsForLoad, prepareAssetsForSave };
+export { inspectAssets, prepareAssetsForLoad, prepareAssetsForSave, rewriteUrls };

package/dist/engine/create-document-engine.cjs

@@ -2,15 +2,20 @@ const require_asset_manifest = require("../assets/asset-manifest.cjs");
 const require_errors = require("./errors.cjs");
 const require_image_check = require("../assets/image-check.cjs");
 const require_asset_pipeline = require("../assets/asset-pipeline.cjs");
+const require_export_area = require("../export/export-area.cjs");
+const require_export_options = require("../export/export-options.cjs");
+const require_object_ids = require("../fabric/object-ids.cjs");
+const require_walk_objects = require("../fabric/walk-objects.cjs");
+const require_preflight_export = require("../export/preflight-export.cjs");
+const require_render_export = require("../export/render-export.cjs");
 require("../document/document-format.cjs");
 const require_ids = require("../document/ids.cjs");
 const require_create_document = require("../document/create-document.cjs");
 const require_validate_document = require("../document/validate-document.cjs");
-const require_walk_objects = require("../fabric/walk-objects.cjs");
 const require_fabric_adapter = require("../fabric/fabric-adapter.cjs");
-const require_object_ids = require("../fabric/object-ids.cjs");
 const require_object_registry = require("../fabric/object-registry.cjs");
 const require_create_history = require("../history/create-history.cjs");
+const require_recovery_controller = require("../recovery/recovery-controller.cjs");
 const require_save_controller = require("../save/save-controller.cjs");
 const require_event_emitter = require("./event-emitter.cjs");
 //#region src/engine/create-document-engine.ts
@@ -70,7 +75,7 @@ function createDocumentEngine(options) {
 			return require_fabric_adapter.serializeCanvas(canvas, registry.propertiesToInclude()).objects;
 		},
 		onChange: (state) => events.emit("history:change", state),
-		onContentChange: () => saving.noteContentChange()
+		onContentChange: () => noteContentChange()
 	});
 	const saving = require_save_controller.createSaveController({
 		getStorage: () => requireStorage(),
@@ -83,10 +88,30 @@ function createDocumentEngine(options) {
 		autosave: options.autosave === true ? {} : options.autosave ?? false,
 		onStateChange: (state) => events.emit("save:status", state),
 		onStart: (document) => events.emit("save:start", { document }),
-		onSuccess: (document) => events.emit("save:success", { document }),
+		onSuccess: (document) => {
+			if (recovery && !saving.state().isDirty) recovery.remove(document.id);
+			events.emit("save:success", { document });
+		},
 		onError: (error) => events.emit("save:error", { error }),
 		onRetry: (event) => events.emit("save:retry", event)
 	});
+	const recovery = options.recovery ? require_recovery_controller.createRecoveryController({
+		...options.recovery,
+		createDocument: () => toDocument(),
+		shouldWrite: () => !destroyed && saving.state().isDirty,
+		onCheckpoint: (record) => events.emit("recovery:checkpoint", {
+			documentId: record.documentId,
+			savedAt: record.savedAt
+		}),
+		onError: (error) => {
+			const reason = error instanceof Error ? error.message : String(error);
+			events.emit("recovery:error", { error: new require_errors.DocumentEngineError("RECOVERY_FAILED", `Could not write the recovery copy: ${reason}`, { cause: error }) });
+		}
+	}) : void 0;
+	function noteContentChange() {
+		saving.noteContentChange();
+		recovery?.schedule();
+	}
 	function toDocument() {
 		ensureUsable();
 		rebuildIndex();
@@ -135,8 +160,11 @@ function createDocumentEngine(options) {
 		activeLoad?.abort();
 		const controller = new AbortController();
 		activeLoad = controller;
-		events.emit("load:start", { documentId: describeDocumentId(input) });
+		const documentId = describeDocumentId(input);
+		events.emit("load:start", { documentId });
 		try {
+			await recovery?.markLoadStarted(documentId);
+			if (controller.signal.aborted) throw new Error("aborted");
 			const checked = checkDocument(input);
 			const { document, warnings } = await require_asset_pipeline.prepareAssetsForLoad(checked, assetOptions, controller.signal);
 			if (controller.signal.aborted) throw new Error("aborted");
@@ -158,6 +186,7 @@ function createDocumentEngine(options) {
 			};
 			rebuildIndex();
 			history.reset();
+			recovery?.cancel();
 			saving.startSession(document.revision ?? 0);
 			canvas.requestRenderAll();
 			if (warnings.length > 0) events.emit("assets:warning", { warnings });
@@ -171,7 +200,10 @@ function createDocumentEngine(options) {
 			events.emit("load:error", { error: engineError });
 			throw engineError;
 		} finally {
-			if (activeLoad === controller) activeLoad = null;
+			if (activeLoad === controller) {
+				activeLoad = null;
+				await recovery?.markLoadFinished();
+			}
 		}
 	}
 	function requireStorage() {
@@ -208,6 +240,7 @@ function createDocumentEngine(options) {
 		documentInfo = require_create_document.createDocumentInfo(newOptions);
 		uploadedUrls.clear();
 		history.reset();
+		recovery?.cancel();
 		saving.startSession(0);
 	}
 	function getObjectById(id) {
@@ -241,6 +274,107 @@ function createDocumentEngine(options) {
 		canvas.requestRenderAll();
 		return images.length;
 	}
+	function fontsOnCanvas() {
+		rebuildIndex();
+		return require_asset_manifest.buildAssetManifest(require_fabric_adapter.serializeCanvas(canvas, registry.propertiesToInclude()).objects).fonts;
+	}
+	async function checkBeforeExport(exportOptions) {
+		ensureUsable();
+		const { format } = require_export_options.normalizeExportOptions(exportOptions);
+		return require_preflight_export.preflightExport(canvas, format, format === "json" ? [] : fontsOnCanvas(), assetOptions);
+	}
+	function describeProblems(check) {
+		return check.problems.map((problem) => problem.message).join("; ");
+	}
+	async function exportContent(exportOptions) {
+		const settings = require_export_options.normalizeExportOptions(exportOptions);
+		const stopIfCancelled = () => {
+			if (settings.signal?.aborted) throw new require_errors.DocumentEngineError("EXPORT_ABORTED", "The export was cancelled");
+		};
+		stopIfCancelled();
+		if (settings.format === "json") {
+			const prepared = await require_asset_pipeline.prepareAssetsForSave(toDocument(), assetOptions, uploadedUrls);
+			stopIfCancelled();
+			return {
+				format: "json",
+				mimeType: require_render_export.mimeTypes.json,
+				blob: new Blob([JSON.stringify(prepared.document)], { type: require_render_export.mimeTypes.json }),
+				width: prepared.document.canvas.width,
+				height: prepared.document.canvas.height,
+				warnings: prepared.warnings,
+				document: prepared.document
+			};
+		}
+		const check = await checkBeforeExport(settings);
+		stopIfCancelled();
+		if (!check.ok) throw new require_errors.DocumentEngineError("EXPORT_BLOCKED", `The export cannot run: ${describeProblems(check)}`, { problems: check.problems });
+		const format = settings.format;
+		try {
+			const rendered = require_render_export.withExportView(canvas, settings.background, format, () => {
+				const area = require_export_area.resolveExportArea(canvas, settings.area, settings.padding);
+				return {
+					area,
+					content: format === "svg" ? require_render_export.renderSvg(canvas, area, settings.scale) : require_render_export.renderRaster(canvas, area, format, settings.scale, settings.quality)
+				};
+			});
+			const blob = format === "svg" ? new Blob([rendered.content], { type: require_render_export.mimeTypes.svg }) : require_render_export.dataUrlToBlob(rendered.content);
+			return {
+				format,
+				mimeType: blob.type || require_render_export.mimeTypes[format],
+				blob,
+				width: Math.round(rendered.area.width * settings.scale),
+				height: Math.round(rendered.area.height * settings.scale),
+				warnings: check.warnings
+			};
+		} catch (error) {
+			if (require_errors.isDocumentEngineError(error)) throw error;
+			if (error?.name === "SecurityError") {
+				const problem = {
+					code: "CROSS_ORIGIN_IMAGE",
+					message: "The browser blocked the export because the canvas shows an image from another site without CORS",
+					objectIds: []
+				};
+				throw new require_errors.DocumentEngineError("EXPORT_BLOCKED", problem.message, {
+					problems: [problem],
+					cause: error
+				});
+			}
+			const reason = error instanceof Error ? error.message : String(error);
+			throw new require_errors.DocumentEngineError("EXPORT_FAILED", `Fabric could not export the canvas: ${reason}`, { cause: error });
+		}
+	}
+	async function exportDocument(exportOptions) {
+		ensureUsable();
+		try {
+			const result = await exportContent(exportOptions);
+			events.emit("export:success", {
+				format: result.format,
+				width: result.width,
+				height: result.height,
+				warnings: result.warnings
+			});
+			return result;
+		} catch (error) {
+			const engineError = require_errors.isDocumentEngineError(error) ? error : new require_errors.DocumentEngineError("EXPORT_FAILED", String(error), { cause: error });
+			events.emit("export:error", { error: engineError });
+			throw engineError;
+		}
+	}
+	function requireRecovery() {
+		ensureUsable();
+		if (!recovery) throw new require_errors.DocumentEngineError("RECOVERY_MISSING", "Pass recovery: { store } to createDocumentEngine to use recovery");
+		return recovery;
+	}
+	async function restoreRecovery(documentId, loadOptions) {
+		const source = requireRecovery();
+		const id = documentId ?? documentInfo.id;
+		const record = await source.read(id);
+		if (!record) throw new require_errors.DocumentEngineError("RECOVERY_NOT_FOUND", `There is no recovery copy for document "${id}"`);
+		const loaded = await loadDocument(await require_recovery_controller.restoreRecordedFiles(record), loadOptions);
+		noteContentChange();
+		events.emit("recovery:restored", { document: loaded });
+		return loaded;
+	}
 	async function travelThroughHistory(direction) {
 		ensureUsable();
 		try {
@@ -258,6 +392,7 @@ function createDocumentEngine(options) {
 		activeLoad?.abort();
 		history.destroy();
 		saving.destroy();
+		recovery?.destroy();
 		canvas.off("object:added", handleObjectAdded);
 		canvas.off("object:removed", handleObjectRemoved);
 		objectsById.clear();
@@ -278,7 +413,7 @@ function createDocumentEngine(options) {
 					...changes
 				}
 			};
-			saving.noteContentChange();
+			noteContentChange();
 		},
 		newDocument,
 		toDocument,
@@ -298,6 +433,14 @@ function createDocumentEngine(options) {
 		},
 		checkAssets,
 		replaceImage,
+		export: exportDocument,
+		preflightExport: checkBeforeExport,
+		flushRecovery: async () => requireRecovery().flush(),
+		getRecoverableDocuments: async () => requireRecovery().list(),
+		getRecovery: async (documentId) => requireRecovery().read(documentId ?? documentInfo.id),
+		restoreRecovery,
+		discardRecovery: async (documentId) => requireRecovery().remove(documentId ?? documentInfo.id),
+		getInterruptedLoad: async () => requireRecovery().interruptedLoad(),
 		transaction(label, work) {
 			ensureUsable();
 			return history.transaction(label, work);

package/dist/engine/create-document-engine.d.cts

@@ -1,9 +1,12 @@
 import { DocumentInfo, FabricDocument } from "../document/document-format.cjs";
 import { AssetManifest } from "../assets/asset-manifest.cjs";
 import { AssetOptions, AssetReport, AssetWarning } from "../assets/asset-pipeline.cjs";
+import { ExportFormat, ExportOptions } from "../export/export-options.cjs";
+import { ExportPreflight } from "../export/preflight-export.cjs";
 import { NewDocumentOptions } from "../document/create-document.cjs";
 import { CustomObjectDefinition } from "../fabric/object-registry.cjs";
 import { HistoryOptions, HistoryState } from "../history/create-history.cjs";
+import { InterruptedLoad, RecoveryOptions, RecoveryRecord } from "../recovery/recovery-controller.cjs";
 import { AutosaveOptions } from "../save/autosave-scheduler.cjs";
 import { RetryOptions } from "../save/retry.cjs";
 import { DocumentEngineError } from "./errors.cjs";
@@ -21,10 +24,20 @@ export interface DocumentEngineOptions {
   autosave?: boolean | AutosaveOptions;
   saveRetry?: RetryOptions;
   assets?: AssetOptions;
+  recovery?: RecoveryOptions;
 }
 export interface LoadOptions {
   restoreCanvasSize?: boolean;
 }
+export interface ExportResult {
+  format: ExportFormat;
+  mimeType: string;
+  blob: Blob;
+  width: number;
+  height: number;
+  warnings: AssetWarning[];
+  document?: FabricDocument;
+}
 export interface DocumentEngineEvents {
   "load:start": {
     documentId: string | undefined;
@@ -54,6 +67,25 @@ export interface DocumentEngineEvents {
   "history:error": {
     error: DocumentEngineError;
   };
+  "recovery:checkpoint": {
+    documentId: string;
+    savedAt: string;
+  };
+  "recovery:restored": {
+    document: FabricDocument;
+  };
+  "recovery:error": {
+    error: DocumentEngineError;
+  };
+  "export:success": {
+    format: ExportFormat;
+    width: number;
+    height: number;
+    warnings: AssetWarning[];
+  };
+  "export:error": {
+    error: DocumentEngineError;
+  };
 }
 export interface DocumentEngine {
   readonly canvas: StaticCanvas;
@@ -82,6 +114,14 @@ export interface DocumentEngine {
   getAssetManifest(): AssetManifest;
   checkAssets(): Promise<AssetReport>;
   replaceImage(oldUrl: string, newUrl: string): Promise<number>;
+  export(options: ExportOptions): Promise<ExportResult>;
+  preflightExport(options: ExportOptions): Promise<ExportPreflight>;
+  flushRecovery(): Promise<void>;
+  getRecoverableDocuments(): Promise<RecoveryRecord[]>;
+  getRecovery(documentId?: string): Promise<RecoveryRecord | undefined>;
+  restoreRecovery(documentId?: string, options?: LoadOptions): Promise<FabricDocument>;
+  discardRecovery(documentId?: string): Promise<void>;
+  getInterruptedLoad(): Promise<InterruptedLoad | undefined>;
   on<Name extends keyof DocumentEngineEvents>(name: Name, handler: (payload: DocumentEngineEvents[Name]) => void): Unsubscribe;
   destroy(): void;
 }

package/dist/engine/create-document-engine.d.ts

@@ -1,9 +1,12 @@
 import { DocumentInfo, FabricDocument } from "../document/document-format.js";
 import { AssetManifest } from "../assets/asset-manifest.js";
 import { AssetOptions, AssetReport, AssetWarning } from "../assets/asset-pipeline.js";
+import { ExportFormat, ExportOptions } from "../export/export-options.js";
+import { ExportPreflight } from "../export/preflight-export.js";
 import { NewDocumentOptions } from "../document/create-document.js";
 import { CustomObjectDefinition } from "../fabric/object-registry.js";
 import { HistoryOptions, HistoryState } from "../history/create-history.js";
+import { InterruptedLoad, RecoveryOptions, RecoveryRecord } from "../recovery/recovery-controller.js";
 import { AutosaveOptions } from "../save/autosave-scheduler.js";
 import { RetryOptions } from "../save/retry.js";
 import { DocumentEngineError } from "./errors.js";
@@ -21,10 +24,20 @@ export interface DocumentEngineOptions {
   autosave?: boolean | AutosaveOptions;
   saveRetry?: RetryOptions;
   assets?: AssetOptions;
+  recovery?: RecoveryOptions;
 }
 export interface LoadOptions {
   restoreCanvasSize?: boolean;
 }
+export interface ExportResult {
+  format: ExportFormat;
+  mimeType: string;
+  blob: Blob;
+  width: number;
+  height: number;
+  warnings: AssetWarning[];
+  document?: FabricDocument;
+}
 export interface DocumentEngineEvents {
   "load:start": {
     documentId: string | undefined;
@@ -54,6 +67,25 @@ export interface DocumentEngineEvents {
   "history:error": {
     error: DocumentEngineError;
   };
+  "recovery:checkpoint": {
+    documentId: string;
+    savedAt: string;
+  };
+  "recovery:restored": {
+    document: FabricDocument;
+  };
+  "recovery:error": {
+    error: DocumentEngineError;
+  };
+  "export:success": {
+    format: ExportFormat;
+    width: number;
+    height: number;
+    warnings: AssetWarning[];
+  };
+  "export:error": {
+    error: DocumentEngineError;
+  };
 }
 export interface DocumentEngine {
   readonly canvas: StaticCanvas;
@@ -82,6 +114,14 @@ export interface DocumentEngine {
   getAssetManifest(): AssetManifest;
   checkAssets(): Promise<AssetReport>;
   replaceImage(oldUrl: string, newUrl: string): Promise<number>;
+  export(options: ExportOptions): Promise<ExportResult>;
+  preflightExport(options: ExportOptions): Promise<ExportPreflight>;
+  flushRecovery(): Promise<void>;
+  getRecoverableDocuments(): Promise<RecoveryRecord[]>;
+  getRecovery(documentId?: string): Promise<RecoveryRecord | undefined>;
+  restoreRecovery(documentId?: string, options?: LoadOptions): Promise<FabricDocument>;
+  discardRecovery(documentId?: string): Promise<void>;
+  getInterruptedLoad(): Promise<InterruptedLoad | undefined>;
   on<Name extends keyof DocumentEngineEvents>(name: Name, handler: (payload: DocumentEngineEvents[Name]) => void): Unsubscribe;
   destroy(): void;
 }