@embedpdf/plugin-render 2.14.4 → 3.0.0-next.0

package/dist/index.js

@@ -1,141 +1,707 @@
-import { BasePlugin } from "@embedpdf/core";
-const _RenderPlugin = class _RenderPlugin extends BasePlugin {
-  constructor(id, registry, config) {
-    super(id, registry);
-    this.config = config;
-  }
-  // No onDocumentLoadingStarted or onDocumentClosed needed!
-  buildCapability() {
-    return {
-      // Active document operations
-      renderPage: (options) => this.renderPage(options),
-      renderPageRect: (options) => this.renderPageRect(options),
-      renderPageRaw: (options) => this.renderPageRaw(options),
-      renderPageRectRaw: (options) => this.renderPageRectRaw(options),
-      // Document-scoped operations
-      forDocument: (documentId) => this.createRenderScope(documentId)
-    };
-  }
-  // ─────────────────────────────────────────────────────────
-  // Document Scoping
-  // ─────────────────────────────────────────────────────────
-  createRenderScope(documentId) {
-    return {
-      renderPage: (options) => this.renderPage(options, documentId),
-      renderPageRect: (options) => this.renderPageRect(options, documentId),
-      renderPageRaw: (options) => this.renderPageRaw(options, documentId),
-      renderPageRectRaw: (options) => this.renderPageRectRaw(options, documentId)
-    };
-  }
-  // ─────────────────────────────────────────────────────────
-  // Core Operations
-  // ─────────────────────────────────────────────────────────
-  renderPage({ pageIndex, options }, documentId) {
-    const id = documentId ?? this.getActiveDocumentId();
-    const coreDoc = this.coreState.core.documents[id];
-    if (!(coreDoc == null ? void 0 : coreDoc.document)) {
-      throw new Error(`Document ${id} not loaded`);
-    }
-    const page = coreDoc.document.pages.find((p) => p.index === pageIndex);
-    if (!page) {
-      throw new Error(`Page ${pageIndex} not found in document ${id}`);
-    }
-    const mergedOptions = {
-      ...options ?? {},
-      withForms: (options == null ? void 0 : options.withForms) ?? this.config.withForms ?? false,
-      withAnnotations: (options == null ? void 0 : options.withAnnotations) ?? this.config.withAnnotations ?? false,
-      imageType: (options == null ? void 0 : options.imageType) ?? this.config.defaultImageType ?? "image/png",
-      imageQuality: (options == null ? void 0 : options.imageQuality) ?? this.config.defaultImageQuality ?? 0.92
-    };
-    return this.engine.renderPage(coreDoc.document, page, mergedOptions);
-  }
-  renderPageRect({ pageIndex, rect, options }, documentId) {
-    const id = documentId ?? this.getActiveDocumentId();
-    const coreDoc = this.coreState.core.documents[id];
-    if (!(coreDoc == null ? void 0 : coreDoc.document)) {
-      throw new Error(`Document ${id} not loaded`);
-    }
-    const page = coreDoc.document.pages.find((p) => p.index === pageIndex);
-    if (!page) {
-      throw new Error(`Page ${pageIndex} not found in document ${id}`);
-    }
-    const mergedOptions = {
-      ...options ?? {},
-      withForms: (options == null ? void 0 : options.withForms) ?? this.config.withForms ?? false,
-      withAnnotations: (options == null ? void 0 : options.withAnnotations) ?? this.config.withAnnotations ?? false,
-      imageType: (options == null ? void 0 : options.imageType) ?? this.config.defaultImageType ?? "image/png",
-      imageQuality: (options == null ? void 0 : options.imageQuality) ?? this.config.defaultImageQuality ?? 0.92
-    };
-    return this.engine.renderPageRect(coreDoc.document, page, rect, mergedOptions);
-  }
-  // ─────────────────────────────────────────────────────────
-  // Raw Rendering (returns ImageDataLike, skips encoding)
-  // ─────────────────────────────────────────────────────────
-  renderPageRaw({ pageIndex, options }, documentId) {
-    const id = documentId ?? this.getActiveDocumentId();
-    const coreDoc = this.coreState.core.documents[id];
-    if (!(coreDoc == null ? void 0 : coreDoc.document)) {
-      throw new Error(`Document ${id} not loaded`);
-    }
-    const page = coreDoc.document.pages.find((p) => p.index === pageIndex);
-    if (!page) {
-      throw new Error(`Page ${pageIndex} not found in document ${id}`);
-    }
-    const mergedOptions = {
-      ...options ?? {},
-      withForms: (options == null ? void 0 : options.withForms) ?? this.config.withForms ?? false,
-      withAnnotations: (options == null ? void 0 : options.withAnnotations) ?? this.config.withAnnotations ?? false
-    };
-    return this.engine.renderPageRaw(coreDoc.document, page, mergedOptions);
-  }
-  renderPageRectRaw({ pageIndex, rect, options }, documentId) {
-    const id = documentId ?? this.getActiveDocumentId();
-    const coreDoc = this.coreState.core.documents[id];
-    if (!(coreDoc == null ? void 0 : coreDoc.document)) {
-      throw new Error(`Document ${id} not loaded`);
-    }
-    const page = coreDoc.document.pages.find((p) => p.index === pageIndex);
-    if (!page) {
-      throw new Error(`Page ${pageIndex} not found in document ${id}`);
-    }
-    const mergedOptions = {
-      ...options ?? {},
-      withForms: (options == null ? void 0 : options.withForms) ?? this.config.withForms ?? false,
-      withAnnotations: (options == null ? void 0 : options.withAnnotations) ?? this.config.withAnnotations ?? false
-    };
-    return this.engine.renderPageRectRaw(coreDoc.document, page, rect, mergedOptions);
-  }
-  // ─────────────────────────────────────────────────────────
-  // Lifecycle
-  // ─────────────────────────────────────────────────────────
-  async initialize(_config) {
-    this.logger.info("RenderPlugin", "Initialize", "Render plugin initialized");
-  }
-  async destroy() {
-    super.destroy();
-  }
+import { CONTINUOUS_RENDER_POLICY, createCapabilityToken, definePlugin, snapFullPageViewport } from "@embedpdf/core";
+import { intersectRects } from "@embedpdf/core-geometry";
+//#region src/paint-plan.ts
+const EMPTY_TILE_PLAN = {
+	engaged: false,
+	paint: [],
+	fetching: [],
+	stamp: "empty"
 };
-_RenderPlugin.id = "render";
-let RenderPlugin = _RenderPlugin;
-const RENDER_PLUGIN_ID = "render";
-const manifest = {
-  id: RENDER_PLUGIN_ID,
-  name: "Render Plugin",
-  version: "1.0.0",
-  provides: ["render"],
-  requires: [],
-  optional: [],
-  defaultConfig: {}
+function resolveTiling(config) {
+	return {
+		tileSize: config?.tileSize ?? 512,
+		scales: config?.scales ?? [
+			1,
+			2,
+			4,
+			8,
+			16,
+			32
+		],
+		engageAt: config?.engageAt ?? 1.25,
+		prefetchMargin: config?.prefetch?.margin ?? .5,
+		velocityBias: config?.prefetch?.velocityBias ?? true,
+		settleMs: config?.settleMs ?? 150
+	};
+}
+//#endregion
+//#region src/raster-store.ts
+/**
+* Client-side mirror of the server's one-door read-through: per-key
+* SINGLEFLIGHT + LRU over encoded page images.
+*
+* The key is the raster's canonical identity (conformed viewport +
+* annotations flag + epoch — see `renderSourceKey`), so the lattice does the
+* caching work: every ask inside one rung is the same key, and rung
+* re-crossings (zoom 1280 → 2560 → back) resolve instantly from the LRU
+* instead of re-rendering. Epoch bumps mint new keys; stale-epoch entries
+* age out through the LRU (they are never re-requested).
+*
+* Consumer aborts are REFCOUNTED: a caller abandoning a fetch (camera moved,
+* layer unmounted) detaches without killing it for other consumers; the
+* underlying engine call aborts only when the LAST in-flight consumer leaves.
+* Resolved entries are kept (evictable by LRU) — an abort after resolution
+* is a no-op by design.
+*/
+var RasterStore = class {
+	constructor(maxEntries = 48) {
+		this.maxEntries = maxEntries;
+		this.entries = /* @__PURE__ */ new Map();
+		this.tick = 0;
+	}
+	acquire(key, fetch, signal) {
+		const existing = this.entries.get(key);
+		if (existing) {
+			existing.used = ++this.tick;
+			return this.attach(key, existing, signal);
+		}
+		const abort = new AbortController();
+		const entry = {
+			promise: void 0,
+			refs: 0,
+			abort,
+			used: ++this.tick
+		};
+		entry.promise = fetch(abort.signal).then((handle) => {
+			entry.handle = handle;
+			return handle;
+		}, (err) => {
+			if (this.entries.get(key) === entry) this.entries.delete(key);
+			throw err;
+		});
+		entry.promise.catch(() => {});
+		this.entries.set(key, entry);
+		this.evict();
+		return this.attach(key, entry, signal);
+	}
+	/** Resolved handle if present — synchronous peek for paint-time reuse. */
+	peek(key) {
+		const entry = this.entries.get(key);
+		if (entry?.handle) entry.used = ++this.tick;
+		return entry?.handle;
+	}
+	get size() {
+		return this.entries.size;
+	}
+	attach(key, entry, signal) {
+		if (signal?.aborted) return Promise.reject(abortReason(signal));
+		entry.refs += 1;
+		if (!signal) {
+			const release = () => {
+				entry.refs -= 1;
+			};
+			entry.promise.then(release, release);
+			return entry.promise;
+		}
+		let settled = false;
+		return new Promise((resolve, reject) => {
+			const onAbort = () => {
+				if (settled) return;
+				settled = true;
+				entry.refs -= 1;
+				if (entry.refs <= 0 && entry.handle === void 0) {
+					entry.abort.abort(abortReason(signal));
+					if (this.entries.get(key) === entry) this.entries.delete(key);
+				}
+				reject(abortReason(signal));
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+			entry.promise.then((handle) => {
+				if (settled) return;
+				settled = true;
+				entry.refs -= 1;
+				signal.removeEventListener("abort", onAbort);
+				resolve(handle);
+			}, (err) => {
+				if (settled) return;
+				settled = true;
+				entry.refs -= 1;
+				signal.removeEventListener("abort", onAbort);
+				reject(err);
+			});
+		});
+	}
+	evict() {
+		if (this.entries.size <= this.maxEntries) return;
+		const candidates = [...this.entries.entries()].filter(([, e]) => e.refs <= 0 && e.handle !== void 0).sort((a, b) => a[1].used - b[1].used);
+		for (const [key] of candidates) {
+			if (this.entries.size <= this.maxEntries) return;
+			this.entries.delete(key);
+		}
+	}
 };
-const RenderPluginPackage = {
-  manifest,
-  create: (registry, config) => new RenderPlugin(RENDER_PLUGIN_ID, registry, config),
-  reducer: () => {
-  },
-  initialState: {}
+function abortReason(signal) {
+	return signal.reason ?? new DOMException("aborted", "AbortError");
+}
+//#endregion
+//#region src/tiles.ts
+function tileGrid(page, scale, tileSize) {
+	return {
+		scale,
+		tileSize,
+		cols: Math.max(1, Math.ceil(page.width * scale / tileSize)),
+		rows: Math.max(1, Math.ceil(page.height * scale / tileSize))
+	};
+}
+/** One tile's edge in page points at its level. */
+const tileSpanPt = (grid) => grid.tileSize / grid.scale;
+/**
+* The tiles of `grid` intersecting a y-down page-point rect, clamped to
+* the page. An empty intersection yields an empty list.
+*/
+function tilesInRect(grid, page, rect) {
+	const span = tileSpanPt(grid);
+	const x0 = Math.max(0, Math.floor(rect.x / span));
+	const y0 = Math.max(0, Math.floor(rect.y / span));
+	const x1 = Math.min(grid.cols - 1, Math.ceil((rect.x + rect.width) / span) - 1);
+	const y1 = Math.min(grid.rows - 1, Math.ceil((rect.y + rect.height) / span) - 1);
+	const out = [];
+	for (let iy = y0; iy <= y1; iy++) for (let ix = x0; ix <= x1; ix++) out.push({
+		ix,
+		iy
+	});
+	return out;
+}
+/** Paint rect: y-down page points, clamped to the page edge. */
+function tilePaintRect(grid, page, c) {
+	const span = tileSpanPt(grid);
+	const x = c.ix * span;
+	const y = c.iy * span;
+	return {
+		x,
+		y,
+		width: Math.min(span, page.width - x),
+		height: Math.min(span, page.height - y)
+	};
+}
+/** Engine target rect: y-UP PDF user space (top > bottom). */
+function tileEngineRect(grid, page, c) {
+	const paint = tilePaintRect(grid, page, c);
+	return {
+		left: paint.x,
+		right: paint.x + paint.width,
+		top: page.height - paint.y,
+		bottom: page.height - (paint.y + paint.height)
+	};
+}
+/**
+* Does a set of PAINTED want-level tiles cover `region` (y-down points)?
+* The retention release check: a retained source may leave the paint list
+* once its visible footprint answers true here. Pure index arithmetic on
+* the aligned grid — the whole reason the pyramid is aligned.
+*/
+function regionCovered(grid, page, region, isPainted) {
+	if (region.width <= 0 || region.height <= 0) return true;
+	for (const c of tilesInRect(grid, page, region)) if (!isPainted(c)) return false;
+	return true;
+}
+/**
+* Inflate a visible rect by a prefetch margin (fractions of the rect's own
+* size per side), optionally velocity-biased: the margin stretches toward
+* the direction of travel and shrinks behind it. Pure — the producer's
+* velocity is just data.
+*/
+function inflateRect(rect, margin, velocity) {
+	const mx = rect.width * margin;
+	const my = rect.height * margin;
+	let left = mx;
+	let right = mx;
+	let up = my;
+	let down = my;
+	if (velocity) {
+		if (velocity.dx > 0) {
+			right = mx * 2;
+			left = mx / 2;
+		} else if (velocity.dx < 0) {
+			left = mx * 2;
+			right = mx / 2;
+		}
+		if (velocity.dy > 0) {
+			down = my * 2;
+			up = my / 2;
+		} else if (velocity.dy < 0) {
+			up = my * 2;
+			down = my / 2;
+		}
+	}
+	return {
+		x: rect.x - left,
+		y: rect.y - up,
+		width: rect.width + left + right,
+		height: rect.height + up + down
+	};
+}
+/** Snap UP through a pyramid's sorted scales; cap at the top. */
+function snapToPyramid(scales, needed) {
+	const sorted = [...scales].sort((a, b) => a - b);
+	return sorted.find((s) => s >= needed) ?? sorted[sorted.length - 1];
+}
+//#endregion
+//#region src/tile-manager.ts
+/**
+* The tile retention state machine. One instance per
+* plugin instance (per document), all levels and pages in one place, over
+* the SAME RasterStore the base renders use.
+*
+* Invariant it enforces: every screen region paints the sharpest PAINTED
+* pixels available; quality per region only goes up until the want set
+* resolves. Mechanics:
+*   - want vs paint: `plan()` schedules fetches for the want set (P0
+*     visible first, P1 prefetch when P0 is fully resolved) and returns a
+*     paint list drawn ONLY from resolved entries — current level AND
+*     retained older generations.
+*   - release-on-occlusion: when a want-level tile reports PAINTED (the
+*     layer's img onload — the decode boundary), retained sources whose
+*     visible footprint is covered by painted want tiles leave the paint
+*     list. Their bytes stay in the RasterStore (demotion, not eviction) —
+*     zoom-back re-promotes from cache.
+*   - epoch exception: an invalidation bump means retained pixels are
+*     WRONG — everything of the old epoch drops immediately.
+*
+* `plan()` is called from selectors: it MUST NOT dispatch. Fetch kickoff
+* is idempotent (the store singleflights); resolution handlers dispatch
+* the wake-up (`onAdvance`) that makes subscribed layers recompute.
+*/
+var TileManager = class {
+	constructor(deps) {
+		this.deps = deps;
+		this.pages = /* @__PURE__ */ new Map();
+	}
+	plan(pon, demand, includeAnnotations) {
+		const { config } = this.deps;
+		const policy = this.deps.getPolicy();
+		const page = this.deps.getPageSize(pon);
+		if (!page) return EMPTY_TILE_PLAN;
+		const epoch = this.deps.getEpoch(pon, includeAnnotations);
+		const state = this.pageState(pon);
+		if (state.epoch !== epoch) {
+			this.abortAll(state);
+			state.entries.clear();
+			state.epoch = epoch;
+			state.wantScale = null;
+			state.planCache = null;
+		}
+		const baseSupplied = policy.kind === "lattice" ? widthOf(snapFullPageViewport(policy, {
+			kind: "width",
+			width: demand.desiredDeviceWidth
+		})) : demand.desiredDeviceWidth;
+		if (demand.desiredDeviceWidth / baseSupplied <= config.engageAt) {
+			if (state.entries.size || state.wantScale !== null) {
+				this.abortAll(state);
+				state.entries.clear();
+				state.wantScale = null;
+				state.planCache = null;
+			}
+			return EMPTY_TILE_PLAN;
+		}
+		const pyramid = policy.kind === "lattice" && policy.tiles ? policy.tiles.scales : config.scales;
+		const wantScale = snapToPyramid(pyramid, demand.desiredDeviceWidth / page.width);
+		const grid = tileGrid(page, wantScale, config.tileSize);
+		const visible = demand.visibleRect ?? {
+			x: 0,
+			y: 0,
+			width: page.width,
+			height: page.height
+		};
+		state.lastVisible = visible;
+		const p0 = tilesInRect(grid, page, visible);
+		const ring = inflateRect(visible, config.prefetchMargin, config.velocityBias ? demand.velocity : void 0);
+		const p0Keys = new Set(p0.map((c) => coordKey(c)));
+		const p1 = tilesInRect(grid, page, ring).filter((c) => !p0Keys.has(coordKey(c)));
+		this.schedule(pon, state, page, grid, wantScale, includeAnnotations, epoch, p0, p1);
+		const demandKey = `${wantScale}|${rectKey(visible)}|e${epoch}`;
+		if (state.planCache && state.planCache.demandKey === demandKey && state.planCache.version === state.version) return state.planCache.plan;
+		const paint = [];
+		const fetching = [];
+		for (const entry of state.entries.values()) {
+			const visIntersect = intersectRects(entry.rect, visible);
+			if (entry.handle) {
+				if (visIntersect.width > 0 && visIntersect.height > 0) paint.push({
+					key: entry.key,
+					scale: entry.scale,
+					rect: entry.rect,
+					z: zOf(pyramid, entry.scale),
+					handle: entry.handle
+				});
+			} else if (entry.scale === wantScale) fetching.push(entry.key);
+		}
+		paint.sort((a, b) => a.z - b.z || a.key.localeCompare(b.key));
+		const plan = {
+			engaged: true,
+			paint,
+			fetching: fetching.sort(),
+			stamp: `${demandKey}|v${state.version}`
+		};
+		state.planCache = {
+			demandKey,
+			version: state.version,
+			plan
+		};
+		return plan;
+	}
+	/** The layer's decode-boundary report: this key's <img> actually painted. */
+	sourcePainted(pon, key) {
+		const state = this.pages.get(pon);
+		const entry = state?.entries.get(key);
+		if (!state || !entry || entry.painted) return;
+		entry.painted = true;
+		this.releaseOccluded(state, entry);
+		state.version += 1;
+		state.planCache = null;
+		this.deps.onAdvance(pon);
+	}
+	/** A lens unmounted its TileLayer: stop fetching, drop bookkeeping.
+	*  Resolved bytes stay in the RasterStore for a re-mount. */
+	releasePage(pon) {
+		const state = this.pages.get(pon);
+		if (!state) return;
+		this.abortAll(state);
+		this.pages.delete(pon);
+	}
+	pageState(pon) {
+		let state = this.pages.get(pon);
+		if (!state) {
+			state = {
+				epoch: -1,
+				wantScale: null,
+				entries: /* @__PURE__ */ new Map(),
+				version: 0,
+				planCache: null,
+				settleTimer: null,
+				pendingLevel: null,
+				lastVisible: null
+			};
+			this.pages.set(pon, state);
+		}
+		return state;
+	}
+	schedule(pon, state, page, grid, wantScale, includeAnnotations, epoch, p0, p1) {
+		const { config } = this.deps;
+		const firstEngage = state.wantScale === null;
+		const levelChanged = state.wantScale !== null && state.wantScale !== wantScale;
+		state.wantScale = wantScale;
+		const wanted = new Set([...p0, ...p1].map((c) => this.tileKey(pon, wantScale, c, includeAnnotations, epoch)));
+		for (const [key, entry] of state.entries) if (entry.handle === void 0 && !wanted.has(key)) {
+			entry.abort?.abort();
+			state.entries.delete(key);
+		}
+		const kickoff = () => {
+			if (this.ensureFetches(pon, state, page, grid, includeAnnotations, epoch, p0)) this.ensureFetches(pon, state, page, grid, includeAnnotations, epoch, p1);
+		};
+		if (levelChanged && config.settleMs > 0) {
+			state.pendingLevel = wantScale;
+			if (state.settleTimer !== null) clearTimeout(state.settleTimer);
+			state.settleTimer = setTimeout(() => {
+				state.settleTimer = null;
+				if (state.pendingLevel === wantScale) kickoff();
+			}, config.settleMs);
+			return;
+		}
+		if (state.settleTimer !== null && !levelChanged && !firstEngage) {
+			clearTimeout(state.settleTimer);
+			state.settleTimer = null;
+			state.pendingLevel = null;
+		}
+		kickoff();
+	}
+	/** Start missing fetches; true when every coord is already resolved. */
+	ensureFetches(pon, state, page, grid, includeAnnotations, epoch, coords) {
+		let allReady = true;
+		for (const coord of coords) {
+			const key = this.tileKey(pon, grid.scale, coord, includeAnnotations, epoch);
+			const existing = state.entries.get(key);
+			if (existing) {
+				if (existing.handle === void 0) allReady = false;
+				continue;
+			}
+			allReady = false;
+			const abort = new AbortController();
+			const entry = {
+				key,
+				scale: grid.scale,
+				coord,
+				rect: tilePaintRect(grid, page, coord),
+				painted: false,
+				abort
+			};
+			state.entries.set(key, entry);
+			this.deps.store.acquire(key, (signal) => this.deps.fetchTile(pon, tileEngineRect(grid, page, coord), grid.scale, includeAnnotations, signal), abort.signal).then((handle) => {
+				if (state.entries.get(key) !== entry) return;
+				entry.handle = handle;
+				state.version += 1;
+				state.planCache = null;
+				this.deps.onAdvance(pon);
+			}, () => {
+				if (state.entries.get(key) === entry) state.entries.delete(key);
+			});
+		}
+		return allReady;
+	}
+	/**
+	* The release rule: after `painted` lands on a want-level tile, retained
+	* sources (any other level) whose footprint ∩ painted-tile region is
+	* covered by PAINTED want-level tiles leave the paint list. Index
+	* arithmetic via the aligned grid — no rectangle geometry.
+	*/
+	releaseOccluded(state, painted) {
+		const wantScale = state.wantScale;
+		if (wantScale === null || painted.scale !== wantScale) return;
+		const page = this.deps.getPageSize(pagePonOf(painted.key));
+		if (!page) return;
+		const grid = tileGrid(page, wantScale, this.deps.config.tileSize);
+		const paintedAt = (c) => {
+			const key = this.tileKey(pagePonOf(painted.key), wantScale, c, annotationsOf(painted.key), state.epoch);
+			return state.entries.get(key)?.painted === true;
+		};
+		for (const [key, entry] of state.entries) {
+			if (entry.scale === wantScale || entry.handle === void 0) continue;
+			const overlap = intersectRects(entry.rect, painted.rect);
+			if (overlap.width <= 0 || overlap.height <= 0) continue;
+			if (regionCovered(grid, page, state.lastVisible ? intersectRects(entry.rect, state.lastVisible) : entry.rect, paintedAt)) state.entries.delete(key);
+		}
+	}
+	abortAll(state) {
+		if (state.settleTimer !== null) {
+			clearTimeout(state.settleTimer);
+			state.settleTimer = null;
+		}
+		for (const entry of state.entries.values()) if (entry.handle === void 0) entry.abort?.abort();
+	}
+	tileKey(pon, scale, c, includeAnnotations, epoch) {
+		return `t:${pon}|s${scale}|${c.ix},${c.iy}|a${includeAnnotations ? 1 : 0}|e${epoch}`;
+	}
 };
-export {
-  RenderPlugin,
-  RenderPluginPackage
+const widthOf = (v) => v.kind === "width" && v.width !== void 0 ? v.width : Number.POSITIVE_INFINITY;
+const coordKey = (c) => `${c.ix},${c.iy}`;
+const rectKey = (r) => `${Math.round(r.x)},${Math.round(r.y)},${Math.round(r.width)},${Math.round(r.height)}`;
+/** Stacking: position in the ascending pyramid (coarse under fine). */
+const zOf = (pyramid, scale) => {
+	const sorted = [...pyramid].sort((a, b) => a - b);
+	const idx = sorted.indexOf(scale);
+	return idx === -1 ? sorted.findIndex((s) => s > scale) : idx;
 };
-//# sourceMappingURL=index.js.map
+const pagePonOf = (key) => Number(key.slice(2, key.indexOf("|")));
+const annotationsOf = (key) => key.includes("|a1|");
+//#endregion
+//#region src/capability.ts
+/**
+* The render capability: the ONE policy consumer in the client stack
+* (the three-layer rule). The engine never snaps; framework
+* layers never see the policy; everything between — conforming a desired
+* scale to the deployment lattice, collapsing same-rung asks in the raster
+* store, exposing stable source keys — happens here.
+*/
+function createRenderCapability(ctx, options = {}) {
+	const store = new RasterStore();
+	const policy = () => ctx.document()?.renderPolicy ?? CONTINUOUS_RENDER_POLICY;
+	const pageOf = (pon) => (ctx.document()?.pages ?? []).find((p) => p.pageObjectNumber === pon);
+	const pageWidthOf = (pon) => {
+		const page = pageOf(pon);
+		if (!page) throw new Error(`render: unknown page object number ${pon}`);
+		return page.size.width;
+	};
+	const conformViewport = (pon, scale) => {
+		const p = policy();
+		if (p.kind !== "lattice") return {
+			kind: "scale",
+			scale
+		};
+		return snapFullPageViewport(p, {
+			kind: "scale",
+			scale
+		}, { pageWidth: pageWidthOf(pon) });
+	};
+	const viewportKey = (viewport) => viewport.kind === "width" ? `w${viewport.width}` : `s${viewport.scale ?? 1}`;
+	const epochOf = (pon, includeAnnotations) => {
+		const s = ctx.getState();
+		const content = s.contentEpochs[pon] ?? 0;
+		if (!includeAnnotations) return content;
+		return content + (s.annotatedEpochs[pon] ?? 0);
+	};
+	const tiles = new TileManager({
+		store,
+		config: resolveTiling(options.tiling),
+		getPolicy: policy,
+		getPageSize: (pon) => pageOf(pon)?.size,
+		getEpoch: epochOf,
+		fetchTile: (pon, rect, scale, includeAnnotations, signal) => {
+			const doc = ctx.doc;
+			if (!doc) return Promise.reject(/* @__PURE__ */ new Error("render: no document bound"));
+			const task = doc.page(pon).render.image({
+				target: {
+					kind: "rect",
+					rect
+				},
+				viewport: {
+					kind: "scale",
+					scale
+				},
+				includeAnnotations
+			});
+			if (signal.aborted) task.abort(signal.reason);
+			else signal.addEventListener("abort", () => task.abort(signal.reason), { once: true });
+			return task;
+		},
+		onAdvance: (pon) => ctx.dispatch({
+			type: "PAINT_ADVANCED",
+			pon
+		})
+	});
+	return {
+		renderPage(pon, { scale, includeAnnotations, signal }) {
+			const doc = ctx.doc;
+			if (!doc) return Promise.reject(/* @__PURE__ */ new Error("render: no document bound"));
+			const annotations = includeAnnotations ?? true;
+			const viewport = conformViewport(pon, scale);
+			const key = `${pon}|${viewportKey(viewport)}|a${annotations ? 1 : 0}|e${epochOf(pon, annotations)}`;
+			return store.acquire(key, (storeSignal) => {
+				const task = doc.page(pon).render.image({
+					viewport,
+					includeAnnotations: annotations
+				});
+				if (storeSignal.aborted) task.abort(storeSignal.reason);
+				else storeSignal.addEventListener("abort", () => task.abort(storeSignal.reason), { once: true });
+				return task;
+			}, signal);
+		},
+		renderSourceKey(pon, { scale, includeAnnotations }) {
+			const annotations = includeAnnotations ?? true;
+			const viewport = conformViewport(pon, scale);
+			return `${pon}|${viewportKey(viewport)}|a${annotations ? 1 : 0}|e${epochOf(pon, annotations)}`;
+		},
+		conformViewport,
+		renderPolicy: policy,
+		tilePlan(pon, demand, opts) {
+			return tiles.plan(pon, demand, opts?.includeAnnotations ?? true);
+		},
+		tilePainted(pon, key) {
+			tiles.sourcePainted(pon, key);
+		},
+		releaseTiles(pon) {
+			tiles.releasePage(pon);
+		},
+		renderEpoch(pon, includeAnnotations = true) {
+			return epochOf(pon, includeAnnotations);
+		},
+		invalidate({ pons, scope = "content" } = {}) {
+			const target = pons ?? (ctx.document()?.pages ?? []).map((p) => p.pageObjectNumber);
+			if (target.length) ctx.dispatch({
+				type: "INVALIDATE",
+				scope,
+				pons: target
+			});
+		}
+	};
+}
+//#endregion
+//#region src/effects.ts
+/**
+* Which pages' ANNOTATED raster a confirmed mutation repaints — the whole
+* event→scope map. Everything the engine emits today is appearance-scoped;
+* when it grows content-mutation events (redaction.applied, content.edited),
+* they get a case here dispatching scope 'content'. Over-invalidation is
+* acceptable (a z-order move that changes nothing repaints one thumb);
+* under-invalidation is the bug.
+*/
+function annotatedPons(event, allPons) {
+	switch (event.type) {
+		case "annotation.created":
+		case "annotation.updated":
+		case "annotation.deleted":
+		case "annotation.moved": return [event.pageObjectNumber];
+		case "form.valueChanged":
+		case "form.effectsApplied": return event.changedWidgets.map((w) => w.pageObjectNumber);
+		case "form.fieldDeleted": return event.removedWidgets.map((w) => w.pageObjectNumber);
+		case "form.fieldCreated":
+		case "form.fieldUpdated":
+		case "form.widgetAttached":
+		case "form.widgetDetached": return event.field.widgets.map((w) => w.pageObjectNumber);
+		case "form.imported":
+		case "form.repaired": return allPons();
+		default: return [];
+	}
+}
+function registerRenderEffects(ctx) {
+	const doc = ctx.doc;
+	if (!doc) return;
+	const allPons = () => (ctx.document()?.pages ?? []).map((p) => p.pageObjectNumber);
+	const unsubscribe = doc.events.subscribe((event) => {
+		if (event.type === "redaction.applied") {
+			const pons = event.results.filter((r) => r.status === "applied").map((r) => r.pageObjectNumber);
+			if (pons.length) ctx.dispatch({
+				type: "INVALIDATE",
+				scope: "content",
+				pons
+			});
+			return;
+		}
+		const pons = annotatedPons(event, allPons);
+		if (pons.length) ctx.dispatch({
+			type: "INVALIDATE",
+			scope: "annotations",
+			pons
+		});
+	});
+	ctx.cleanup(unsubscribe);
+}
+//#endregion
+//#region src/reducer.ts
+const initialRenderState = () => ({
+	contentEpochs: {},
+	annotatedEpochs: {},
+	paintVersions: {}
+});
+const bump = (epochs, pons) => {
+	const next = { ...epochs };
+	for (const pon of pons) next[pon] = (next[pon] ?? 0) + 1;
+	return next;
+};
+/** Pure. Two transitions: bump the touched pages' ledger for the fact's
+*  scope (one action per fact, so a batch result bumps each pon once — a
+*  'content' fact bumps ONLY the content ledger; annotated readers sum both,
+*  which is how content invalidation reaches them too), and the tile
+*  wake-up counter. The render POLICY is deliberately NOT here — it's a
+*  document fact on `DocumentMeta`, materialized by the kernel at open. */
+const renderReducer = (state, a) => {
+	if (a.type === "PAINT_ADVANCED") return {
+		...state,
+		paintVersions: bump(state.paintVersions, [a.pon])
+	};
+	if (a.type !== "INVALIDATE" || a.pons.length === 0) return state;
+	return a.scope === "content" ? {
+		...state,
+		contentEpochs: bump(state.contentEpochs, a.pons)
+	} : {
+		...state,
+		annotatedEpochs: bump(state.annotatedEpochs, a.pons)
+	};
+};
+//#endregion
+//#region src/types.ts
+const RenderToken = createCapabilityToken("render");
+//#endregion
+//#region src/render.plugin.ts
+/**
+* Document-scoped. The ONE policy consumer in the client stack: the doc-bind
+* effect resolves the engine's advertised render
+* policy; `renderPage` conforms desired scales to it and collapses
+* same-rung asks in the raster store; the tile manager turns host-supplied
+* demand into a retention-safe paint plan over the SAME store. State is the
+* per-page ledger — raster versions (two doors: the document event stream's
+* built-in map and the `invalidate` verb), the policy latch, and the tile
+* wake-up counter. Layers key on `renderSourceKey`/`tilePlan` and refetch
+* exactly when those change.
+*/
+const renderPlugin = (options = {}) => definePlugin({
+	id: "render",
+	scope: "document",
+	token: RenderToken,
+	initialState: initialRenderState,
+	reduce: renderReducer,
+	capability: (ctx) => createRenderCapability(ctx, options),
+	effects: registerRenderEffects
+});
+//#endregion
+export { RenderToken, renderPlugin };
+
+//# sourceMappingURL=index.js.map