@embedpdf/plugin-render 3.0.0-next.14 → 3.0.0-next.16

package/dist/contract-uc5nOice.d.cts

@@ -0,0 +1,279 @@
+import { BatchResult, DeepPartial, EngineRenderPolicy, EventHook, EventOrigin, OperationOptions, PageImageHandle, PageImageOptions, PageRef, SettingsApi } from "@embedpdf/core";
+import { Rect } from "@embedpdf/core-geometry";
+//#region src/paint-plan.d.ts
+/**
+ * The demand a page host supplies through dependency inversion:
+ * plugin-render defines the shape, producers fill it. The Stage's page
+ * host knows the camera and supplies `visibleRect`/`velocity`; a
+ * stage-less `<PageView>` supplies neither — absent `visibleRect` means
+ * "assume the whole page is visible", which a thumbnail-sized demand
+ * turns into "no tiles engage" by arithmetic, not configuration.
+ */
+interface PageViewDemand {
+  /** Desired device pixels across the page's unrotated content width. */
+  desiredDeviceWidth: number;
+  /** Visible page region — y-down page points. Absent means the whole page. */
+  visibleRect?: Rect;
+  /** Scroll velocity in page points/s — prefetch direction bias only. */
+  velocity?: {
+    dx: number;
+    dy: number;
+  };
+}
+/**
+ * Whether two demands ask for the same thing. A host builds a new demand object on every camera
+ * frame; a layer that compares with this sets it again (and plans again) only when it changed.
+ */
+declare function samePageViewDemand(left: PageViewDemand, right: PageViewDemand): boolean;
+/**
+ * One tile the layer should have in the DOM. `key` is the reconciliation
+ * identity (stable across plan recomputes — keyed lists preserve the DOM
+ * node, which is the retention mechanism); `rect` is y-down page points
+ * inside the unrotated content box; `z` stacks by resolution so arriving
+ * sharper tiles occlude retained coarser ones per region.
+ */
+interface TilePaintSource {
+  key: string;
+  scale: number;
+  rect: Rect;
+  z: number;
+  handle: PageImageHandle;
+}
+/**
+ * What a tile plane paints right now. `paint` draws only from resolved
+ * rasters — retained generations live here until the release rules fire;
+ * "loading" never reaches the DOM. `fetching` is diagnostic (badge/tests).
+ */
+interface TilePaintPlan {
+  /** Tiles engaged at all? False = the base rung fully covers demand. */
+  engaged: boolean;
+  paint: TilePaintSource[];
+  /** Keys currently in flight (want-set members not yet resolved). */
+  fetching: string[];
+  /** Memoization stamp — a new object appears only when this changes. */
+  stamp: string;
+}
+/**
+ * The base-plane strategy: the pixel budget and the render points below it.
+ * Device px throughout (CSS px × devicePixelRatio).
+ */
+interface FullPageOptions {
+  /**
+   * The budget: no full-page raster ever renders wider. Small by design —
+   * the base is the instant backdrop; sharpness past it is the tile plane's
+   * job. Default 640.
+   */
+  maxWidth?: number;
+  /**
+   * Render points under a `continuous` policy. `'exact'` (default) renders
+   * the settled demand precisely — resting pixels are never resampled, the
+   * only way ~1px text stems stay crisp on dpr-1 screens. A width ladder
+   * opts into rung caching instead (defensible on dpr≥2 embeds). An
+   * advertised deployment lattice always wins over either.
+   */
+  quantize?: 'exact' | readonly number[];
+}
+/** The tile-plane strategy. Pass `tiles: false` to disable the plane. */
+interface TilesOptions {
+  /** Tile edge in device px. Default 512 (policy `tileSizes` win when advertised). */
+  size?: number;
+  /**
+   * Tile levels under a `continuous` policy: `'exact'` (default) renders the
+   * settled scale precisely; a scale ladder opts into pyramid reuse. An
+   * advertised `policy.tiles` block always wins.
+   */
+  quantize?: 'exact' | readonly number[];
+  /**
+   * Exact-mode safety clamp on the tile level (device px per point) — the
+   * sharpness ceiling. Past `maxScale × pageWidth` device px of demand,
+   * tiles CSS-stretch instead of re-rendering. Per-screen tile cost is
+   * constant at any level, so this bounds nothing but numeric range.
+   * Default 128 (≈ 6,400% zoom on a letter page at dpr 2).
+   */
+  maxScale?: number;
+  /**
+   * Overlap neighboring tiles by this many device pixels per shared edge
+   * (each tile renders a slightly larger region and is placed to match).
+   * Kills hairline seams whenever tiles display at anything other than 1:1 —
+   * separate `<img>`s at fractional boundaries each get partial-coverage
+   * edge anti-aliasing, and bilinear scaling smears their last row — by
+   * making every edge land over the neighbor's identical content instead of
+   * the backdrop. Default 1; 0 disables.
+   */
+  bleed?: number;
+  /**
+   * Sharpness deficit (desired ÷ supplied-by-base) above which tiles engage.
+   * Resolved default: 1.0 when the base is exact (nothing may rest
+   * stretched), 1.25 under a lattice.
+   */
+  engageAt?: number;
+  /** Prefetch ring around the visible rect. */
+  prefetch?: {
+    /** Extra coverage per side, in fractions of the visible rect. Default 0.5. */
+    margin?: number;
+    /** Stretch the ring toward scroll direction. Default true. */
+    velocityBias?: boolean;
+  };
+  /**
+   * Settle gate for level changes (a zoom in motion): tile fetches for a new
+   * level wait this long; pan-driven fetches at the current level fire
+   * immediately. Default 150ms; 0 disables.
+   */
+  settleMs?: number;
+}
+//#endregion
+//#region src/token.d.ts
+declare const RenderToken: import("@embedpdf/core").CapabilityToken<RenderCapability>;
+//#endregion
+//#region src/contract.d.ts
+/** Encode format the engine can produce for a raster. */
+type RenderFormat = NonNullable<PageImageOptions['format']>;
+/**
+ * The render strategy: what the viewer chooses to spend, and which render
+ * points it uses when the engine permits anything. The shape mirrors the
+ * deployment policy (`policy.fullPage` / `policy.tiles`), and the one
+ * composition rule is: a strategy value applies as written under a
+ * `continuous` policy, and the advertised lattice wins when there is one,
+ * so the same settings run unchanged against local and cloud. They belong to
+ * the plugin as registered: `updateSettings()` changes every document.
+ */
+interface RenderSettings {
+  /** Base plane: the pixel budget + render points. */
+  readonly fullPage: FullPageOptions;
+  /** Tile plane strategy; `false` disables the plane entirely. */
+  readonly tiles: TilesOptions | false;
+  /**
+   * Encode format for both planes. Unset → engine default (png local, the
+   * deployment's format on cloud). `'bmp'` is the local fast path — no
+   * compression, no encoder-worker round trip; under a lattice it conforms
+   * to `policy.formats`.
+   */
+  readonly format: RenderFormat | undefined;
+  /** WebP quality from 0 (smallest) to 1 (best); PNG and BMP ignore it. */
+  readonly quality: number | undefined;
+  /** Diagnostic logging of tile scheduling and fetch outcomes (console `debug`). */
+  readonly debug: boolean;
+}
+/** What the render settings are when the app registers none. */
+declare const RENDER_DEFAULTS: RenderSettings;
+/** What `renderPlugin(config)` takes: any of the settings, merged over the defaults. */
+type RenderConfig = DeepPartial<RenderSettings>;
+/**
+ * What a picture draws beside the page content. An option left out draws
+ * what the user may read: the annotations with `doc.annotate.read`, the form
+ * fields with `doc.forms.read`, and no form fields when `includeAnnotations`
+ * is `false`. `true` for something the user may not read is refused
+ * (`permission-denied`). Leave out what you paint yourself: a layer that
+ * paints annotations passes `includeAnnotations: false`, which leaves the
+ * form fields out too unless you ask for them (`includeFormFields: true`).
+ */
+interface PageLayerOptions {
+  /** Draw the annotations (form fields' widgets excepted). */
+  includeAnnotations?: boolean;
+  /** Draw the form fields, each in the state its field shows. */
+  includeFormFields?: boolean;
+}
+/**
+ * An encoded page image: `source` is bytes or a URL, `format`/`contentType`
+ * say what they are, `width`/`height` its pixel size, and
+ * `objectUrl()` mints a revocable object URL for an `<img>`.
+ */
+type PageImage = PageImageHandle;
+interface RenderPageOptions extends OperationOptions, PageLayerOptions {
+  /** Exact output width in device pixels (height keeps the page's aspect). */
+  width?: number;
+  /** Device pixels per PDF point; ignored when `width` is given. Default 1. */
+  scale?: number;
+  /** Per-call encode overrides; default to the plugin's strategy. */
+  format?: RenderFormat;
+  quality?: number;
+}
+interface RenderThumbnailOptions extends OperationOptions, PageLayerOptions {
+  /** The thumbnail's width in device pixels. */
+  maxWidth: number;
+}
+interface RenderPagesOptions extends RenderPageOptions {
+  /** Renders in flight at once (default 4). */
+  concurrency?: number;
+}
+/** One entry of a batch render. */
+interface PageRender {
+  readonly page: PageRef;
+  readonly image: PageImage;
+}
+/**
+ * The invalidation scopes — every pixel-changing fact is one of them:
+ *
+ *   'annotations' — an annotation changed. Pictures without annotations keep
+ *                   their pixels.
+ *   'fields'      — a form field changed: a fill, a widget's place or look,
+ *                   a signing. Pictures without form fields keep their pixels.
+ *   'content'     — the page itself changed (redaction applied, flattened).
+ *                   Invalidates every picture of the page.
+ */
+type InvalidateScope = 'content' | 'annotations' | 'fields';
+interface InvalidateOptions {
+  /** The pages whose pixels changed, by ref or index; omitted = every page. */
+  pages?: readonly (PageRef | number)[];
+  /** Defaults to `'content'` — a caller who doesn't say is safest repainted fully. */
+  scope?: InvalidateScope;
+}
+/** Pixels changed on these pages: a confirmed document mutation (own or
+ *  remote) or an `invalidate` call. Anything holding a rendered bitmap refetches. */
+interface RenderInvalidatedEvent {
+  readonly pages: readonly PageRef[];
+  readonly scope: InvalidateScope;
+  /**
+   * Where the document mutation came from. Null when a caller requested the
+   * invalidation through {@link RenderCapability.invalidate}.
+   */
+  readonly origin: EventOrigin | null;
+}
+interface RenderCapability extends SettingsApi<RenderSettings> {
+  /**
+   * Would page rasters be served to this session (`doc.render`)? When false
+   * every render refuses locally with `permission-denied` — no doomed engine
+   * round-trips — and a host can show its "no preview" state instead.
+   */
+  canRender(): boolean;
+  /**
+   * Render one page, by its ref or its index, at the requested size. The
+   * size is honoured exactly (nothing is snapped to the viewer's render
+   * points); the shared raster cache serves the call when it already holds a
+   * matching image. Rejects `permission-denied` without `doc.render`,
+   * `not-found` for a page that is not in this document,
+   * `operation-cancelled` when `signal` fires.
+   */
+  renderPage(page: PageRef | number, options?: RenderPageOptions): Promise<PageImage>;
+  /** Sugar for a small raster at `maxWidth` device pixels. Rejects like `renderPage`. */
+  renderThumbnail(page: PageRef | number, options: RenderThumbnailOptions): Promise<PageImage>;
+  /**
+   * Render several pages with bounded concurrency; best-effort per page: each
+   * rendered page with its image, in the order given, and each page that
+   * failed (as given) with why. Rejects `permission-denied` without
+   * `doc.render`, `operation-cancelled` when `signal` fires.
+   */
+  renderPages(pages: readonly (PageRef | number)[], options?: RenderPagesOptions): Promise<BatchResult<PageRender, PageRef | number>>;
+  /** The deployment's advertised render policy (a document fact). */
+  getRenderPolicy(): EngineRenderPolicy;
+  /**
+   * The version of the picture the given options would produce. Key a
+   * long-lived render on it: when it bumps, refetch. A picture versions on
+   * content facts, plus annotation facts when it draws annotations and form
+   * facts when it draws form fields. Bumps only on confirmed mutations —
+   * never optimistically. 0 for a page that isn't in the document.
+   */
+  getRenderEpoch(page: PageRef | number, layers?: PageLayerOptions): number;
+  /**
+   * Declare that page pixels changed — the open door for facts the built-in
+   * event map doesn't know (a plugin's own mutation vocabulary, anything
+   * third-party). Call at confirmation, never for optimistic previews.
+   * Fires `onInvalidated`; a page that isn't in the document is skipped.
+   */
+  invalidate(options?: InvalidateOptions): void;
+  /** Pages' pixels changed and they will redraw. */
+  readonly onInvalidated: EventHook<RenderInvalidatedEvent>;
+}
+//#endregion
+export { PageViewDemand as _, PageRender as a, TilesOptions as b, RenderConfig as c, RenderPageOptions as d, RenderPagesOptions as f, FullPageOptions as g, RenderToken as h, PageLayerOptions as i, RenderFormat as l, RenderThumbnailOptions as m, InvalidateScope as n, RENDER_DEFAULTS as o, RenderSettings as p, PageImage as r, RenderCapability as s, InvalidateOptions as t, RenderInvalidatedEvent as u, TilePaintPlan as v, samePageViewDemand as x, TilePaintSource as y };
+//# sourceMappingURL=contract-uc5nOice.d.cts.map

package/dist/contract-uc5nOice.d.ts

@@ -0,0 +1,279 @@
+import { BatchResult, DeepPartial, EngineRenderPolicy, EventHook, EventOrigin, OperationOptions, PageImageHandle, PageImageOptions, PageRef, SettingsApi } from "@embedpdf/core";
+import { Rect } from "@embedpdf/core-geometry";
+//#region src/paint-plan.d.ts
+/**
+ * The demand a page host supplies through dependency inversion:
+ * plugin-render defines the shape, producers fill it. The Stage's page
+ * host knows the camera and supplies `visibleRect`/`velocity`; a
+ * stage-less `<PageView>` supplies neither — absent `visibleRect` means
+ * "assume the whole page is visible", which a thumbnail-sized demand
+ * turns into "no tiles engage" by arithmetic, not configuration.
+ */
+interface PageViewDemand {
+  /** Desired device pixels across the page's unrotated content width. */
+  desiredDeviceWidth: number;
+  /** Visible page region — y-down page points. Absent means the whole page. */
+  visibleRect?: Rect;
+  /** Scroll velocity in page points/s — prefetch direction bias only. */
+  velocity?: {
+    dx: number;
+    dy: number;
+  };
+}
+/**
+ * Whether two demands ask for the same thing. A host builds a new demand object on every camera
+ * frame; a layer that compares with this sets it again (and plans again) only when it changed.
+ */
+declare function samePageViewDemand(left: PageViewDemand, right: PageViewDemand): boolean;
+/**
+ * One tile the layer should have in the DOM. `key` is the reconciliation
+ * identity (stable across plan recomputes — keyed lists preserve the DOM
+ * node, which is the retention mechanism); `rect` is y-down page points
+ * inside the unrotated content box; `z` stacks by resolution so arriving
+ * sharper tiles occlude retained coarser ones per region.
+ */
+interface TilePaintSource {
+  key: string;
+  scale: number;
+  rect: Rect;
+  z: number;
+  handle: PageImageHandle;
+}
+/**
+ * What a tile plane paints right now. `paint` draws only from resolved
+ * rasters — retained generations live here until the release rules fire;
+ * "loading" never reaches the DOM. `fetching` is diagnostic (badge/tests).
+ */
+interface TilePaintPlan {
+  /** Tiles engaged at all? False = the base rung fully covers demand. */
+  engaged: boolean;
+  paint: TilePaintSource[];
+  /** Keys currently in flight (want-set members not yet resolved). */
+  fetching: string[];
+  /** Memoization stamp — a new object appears only when this changes. */
+  stamp: string;
+}
+/**
+ * The base-plane strategy: the pixel budget and the render points below it.
+ * Device px throughout (CSS px × devicePixelRatio).
+ */
+interface FullPageOptions {
+  /**
+   * The budget: no full-page raster ever renders wider. Small by design —
+   * the base is the instant backdrop; sharpness past it is the tile plane's
+   * job. Default 640.
+   */
+  maxWidth?: number;
+  /**
+   * Render points under a `continuous` policy. `'exact'` (default) renders
+   * the settled demand precisely — resting pixels are never resampled, the
+   * only way ~1px text stems stay crisp on dpr-1 screens. A width ladder
+   * opts into rung caching instead (defensible on dpr≥2 embeds). An
+   * advertised deployment lattice always wins over either.
+   */
+  quantize?: 'exact' | readonly number[];
+}
+/** The tile-plane strategy. Pass `tiles: false` to disable the plane. */
+interface TilesOptions {
+  /** Tile edge in device px. Default 512 (policy `tileSizes` win when advertised). */
+  size?: number;
+  /**
+   * Tile levels under a `continuous` policy: `'exact'` (default) renders the
+   * settled scale precisely; a scale ladder opts into pyramid reuse. An
+   * advertised `policy.tiles` block always wins.
+   */
+  quantize?: 'exact' | readonly number[];
+  /**
+   * Exact-mode safety clamp on the tile level (device px per point) — the
+   * sharpness ceiling. Past `maxScale × pageWidth` device px of demand,
+   * tiles CSS-stretch instead of re-rendering. Per-screen tile cost is
+   * constant at any level, so this bounds nothing but numeric range.
+   * Default 128 (≈ 6,400% zoom on a letter page at dpr 2).
+   */
+  maxScale?: number;
+  /**
+   * Overlap neighboring tiles by this many device pixels per shared edge
+   * (each tile renders a slightly larger region and is placed to match).
+   * Kills hairline seams whenever tiles display at anything other than 1:1 —
+   * separate `<img>`s at fractional boundaries each get partial-coverage
+   * edge anti-aliasing, and bilinear scaling smears their last row — by
+   * making every edge land over the neighbor's identical content instead of
+   * the backdrop. Default 1; 0 disables.
+   */
+  bleed?: number;
+  /**
+   * Sharpness deficit (desired ÷ supplied-by-base) above which tiles engage.
+   * Resolved default: 1.0 when the base is exact (nothing may rest
+   * stretched), 1.25 under a lattice.
+   */
+  engageAt?: number;
+  /** Prefetch ring around the visible rect. */
+  prefetch?: {
+    /** Extra coverage per side, in fractions of the visible rect. Default 0.5. */
+    margin?: number;
+    /** Stretch the ring toward scroll direction. Default true. */
+    velocityBias?: boolean;
+  };
+  /**
+   * Settle gate for level changes (a zoom in motion): tile fetches for a new
+   * level wait this long; pan-driven fetches at the current level fire
+   * immediately. Default 150ms; 0 disables.
+   */
+  settleMs?: number;
+}
+//#endregion
+//#region src/token.d.ts
+declare const RenderToken: import("@embedpdf/core").CapabilityToken<RenderCapability>;
+//#endregion
+//#region src/contract.d.ts
+/** Encode format the engine can produce for a raster. */
+type RenderFormat = NonNullable<PageImageOptions['format']>;
+/**
+ * The render strategy: what the viewer chooses to spend, and which render
+ * points it uses when the engine permits anything. The shape mirrors the
+ * deployment policy (`policy.fullPage` / `policy.tiles`), and the one
+ * composition rule is: a strategy value applies as written under a
+ * `continuous` policy, and the advertised lattice wins when there is one,
+ * so the same settings run unchanged against local and cloud. They belong to
+ * the plugin as registered: `updateSettings()` changes every document.
+ */
+interface RenderSettings {
+  /** Base plane: the pixel budget + render points. */
+  readonly fullPage: FullPageOptions;
+  /** Tile plane strategy; `false` disables the plane entirely. */
+  readonly tiles: TilesOptions | false;
+  /**
+   * Encode format for both planes. Unset → engine default (png local, the
+   * deployment's format on cloud). `'bmp'` is the local fast path — no
+   * compression, no encoder-worker round trip; under a lattice it conforms
+   * to `policy.formats`.
+   */
+  readonly format: RenderFormat | undefined;
+  /** WebP quality from 0 (smallest) to 1 (best); PNG and BMP ignore it. */
+  readonly quality: number | undefined;
+  /** Diagnostic logging of tile scheduling and fetch outcomes (console `debug`). */
+  readonly debug: boolean;
+}
+/** What the render settings are when the app registers none. */
+declare const RENDER_DEFAULTS: RenderSettings;
+/** What `renderPlugin(config)` takes: any of the settings, merged over the defaults. */
+type RenderConfig = DeepPartial<RenderSettings>;
+/**
+ * What a picture draws beside the page content. An option left out draws
+ * what the user may read: the annotations with `doc.annotate.read`, the form
+ * fields with `doc.forms.read`, and no form fields when `includeAnnotations`
+ * is `false`. `true` for something the user may not read is refused
+ * (`permission-denied`). Leave out what you paint yourself: a layer that
+ * paints annotations passes `includeAnnotations: false`, which leaves the
+ * form fields out too unless you ask for them (`includeFormFields: true`).
+ */
+interface PageLayerOptions {
+  /** Draw the annotations (form fields' widgets excepted). */
+  includeAnnotations?: boolean;
+  /** Draw the form fields, each in the state its field shows. */
+  includeFormFields?: boolean;
+}
+/**
+ * An encoded page image: `source` is bytes or a URL, `format`/`contentType`
+ * say what they are, `width`/`height` its pixel size, and
+ * `objectUrl()` mints a revocable object URL for an `<img>`.
+ */
+type PageImage = PageImageHandle;
+interface RenderPageOptions extends OperationOptions, PageLayerOptions {
+  /** Exact output width in device pixels (height keeps the page's aspect). */
+  width?: number;
+  /** Device pixels per PDF point; ignored when `width` is given. Default 1. */
+  scale?: number;
+  /** Per-call encode overrides; default to the plugin's strategy. */
+  format?: RenderFormat;
+  quality?: number;
+}
+interface RenderThumbnailOptions extends OperationOptions, PageLayerOptions {
+  /** The thumbnail's width in device pixels. */
+  maxWidth: number;
+}
+interface RenderPagesOptions extends RenderPageOptions {
+  /** Renders in flight at once (default 4). */
+  concurrency?: number;
+}
+/** One entry of a batch render. */
+interface PageRender {
+  readonly page: PageRef;
+  readonly image: PageImage;
+}
+/**
+ * The invalidation scopes — every pixel-changing fact is one of them:
+ *
+ *   'annotations' — an annotation changed. Pictures without annotations keep
+ *                   their pixels.
+ *   'fields'      — a form field changed: a fill, a widget's place or look,
+ *                   a signing. Pictures without form fields keep their pixels.
+ *   'content'     — the page itself changed (redaction applied, flattened).
+ *                   Invalidates every picture of the page.
+ */
+type InvalidateScope = 'content' | 'annotations' | 'fields';
+interface InvalidateOptions {
+  /** The pages whose pixels changed, by ref or index; omitted = every page. */
+  pages?: readonly (PageRef | number)[];
+  /** Defaults to `'content'` — a caller who doesn't say is safest repainted fully. */
+  scope?: InvalidateScope;
+}
+/** Pixels changed on these pages: a confirmed document mutation (own or
+ *  remote) or an `invalidate` call. Anything holding a rendered bitmap refetches. */
+interface RenderInvalidatedEvent {
+  readonly pages: readonly PageRef[];
+  readonly scope: InvalidateScope;
+  /**
+   * Where the document mutation came from. Null when a caller requested the
+   * invalidation through {@link RenderCapability.invalidate}.
+   */
+  readonly origin: EventOrigin | null;
+}
+interface RenderCapability extends SettingsApi<RenderSettings> {
+  /**
+   * Would page rasters be served to this session (`doc.render`)? When false
+   * every render refuses locally with `permission-denied` — no doomed engine
+   * round-trips — and a host can show its "no preview" state instead.
+   */
+  canRender(): boolean;
+  /**
+   * Render one page, by its ref or its index, at the requested size. The
+   * size is honoured exactly (nothing is snapped to the viewer's render
+   * points); the shared raster cache serves the call when it already holds a
+   * matching image. Rejects `permission-denied` without `doc.render`,
+   * `not-found` for a page that is not in this document,
+   * `operation-cancelled` when `signal` fires.
+   */
+  renderPage(page: PageRef | number, options?: RenderPageOptions): Promise<PageImage>;
+  /** Sugar for a small raster at `maxWidth` device pixels. Rejects like `renderPage`. */
+  renderThumbnail(page: PageRef | number, options: RenderThumbnailOptions): Promise<PageImage>;
+  /**
+   * Render several pages with bounded concurrency; best-effort per page: each
+   * rendered page with its image, in the order given, and each page that
+   * failed (as given) with why. Rejects `permission-denied` without
+   * `doc.render`, `operation-cancelled` when `signal` fires.
+   */
+  renderPages(pages: readonly (PageRef | number)[], options?: RenderPagesOptions): Promise<BatchResult<PageRender, PageRef | number>>;
+  /** The deployment's advertised render policy (a document fact). */
+  getRenderPolicy(): EngineRenderPolicy;
+  /**
+   * The version of the picture the given options would produce. Key a
+   * long-lived render on it: when it bumps, refetch. A picture versions on
+   * content facts, plus annotation facts when it draws annotations and form
+   * facts when it draws form fields. Bumps only on confirmed mutations —
+   * never optimistically. 0 for a page that isn't in the document.
+   */
+  getRenderEpoch(page: PageRef | number, layers?: PageLayerOptions): number;
+  /**
+   * Declare that page pixels changed — the open door for facts the built-in
+   * event map doesn't know (a plugin's own mutation vocabulary, anything
+   * third-party). Call at confirmation, never for optimistic previews.
+   * Fires `onInvalidated`; a page that isn't in the document is skipped.
+   */
+  invalidate(options?: InvalidateOptions): void;
+  /** Pages' pixels changed and they will redraw. */
+  readonly onInvalidated: EventHook<RenderInvalidatedEvent>;
+}
+//#endregion
+export { PageViewDemand as _, PageRender as a, TilesOptions as b, RenderConfig as c, RenderPageOptions as d, RenderPagesOptions as f, FullPageOptions as g, RenderToken as h, PageLayerOptions as i, RenderFormat as l, RenderThumbnailOptions as m, InvalidateScope as n, RENDER_DEFAULTS as o, RenderSettings as p, PageImage as r, RenderCapability as s, InvalidateOptions as t, RenderInvalidatedEvent as u, TilePaintPlan as v, samePageViewDemand as x, TilePaintSource as y };
+//# sourceMappingURL=contract-uc5nOice.d.ts.map

package/dist/contract.cjs

@@ -1,3 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_contract = require("./contract-Bvlo2Ukp.cjs");
+const require_contract = require("./contract-CGcu-84H.cjs");
+exports.RENDER_DEFAULTS = require_contract.RENDER_DEFAULTS;
 exports.RenderToken = require_contract.RenderToken;
+exports.samePageViewDemand = require_contract.samePageViewDemand;

package/dist/contract.d.cts

@@ -1,2 +1,2 @@
-import { a as RenderPluginOptions, c as FullPageOptions, d as TilePaintSource, f as TilesOptions, i as RenderCapability, l as PageViewDemand, n as PaintSettings, o as RenderState, s as RenderToken, t as InvalidateScope, u as TilePaintPlan } from "./contract-CWPMd1OW.cjs";
-export { type FullPageOptions, type InvalidateScope, type PageViewDemand, type PaintSettings, type RenderCapability, type RenderPluginOptions, type RenderState, RenderToken, type TilePaintPlan, type TilePaintSource, type TilesOptions };
+import { _ as PageViewDemand, a as PageRender, b as TilesOptions, c as RenderConfig, d as RenderPageOptions, f as RenderPagesOptions, g as FullPageOptions, h as RenderToken, i as PageLayerOptions, l as RenderFormat, m as RenderThumbnailOptions, n as InvalidateScope, o as RENDER_DEFAULTS, p as RenderSettings, r as PageImage, s as RenderCapability, t as InvalidateOptions, u as RenderInvalidatedEvent, x as samePageViewDemand } from "./contract-uc5nOice.cjs";
+export { type FullPageOptions, InvalidateOptions, InvalidateScope, PageImage, PageLayerOptions, PageRender, type PageViewDemand, type PageViewDemand as ViewDemandInput, RENDER_DEFAULTS, RenderCapability, RenderConfig, RenderFormat, RenderInvalidatedEvent, RenderPageOptions, RenderPagesOptions, RenderSettings, RenderThumbnailOptions, RenderToken, type TilesOptions, samePageViewDemand };

package/dist/contract.d.ts

@@ -1,2 +1,2 @@
-import { a as RenderPluginOptions, c as FullPageOptions, d as TilePaintSource, f as TilesOptions, i as RenderCapability, l as PageViewDemand, n as PaintSettings, o as RenderState, s as RenderToken, t as InvalidateScope, u as TilePaintPlan } from "./contract-CWPMd1OW.js";
-export { type FullPageOptions, type InvalidateScope, type PageViewDemand, type PaintSettings, type RenderCapability, type RenderPluginOptions, type RenderState, RenderToken, type TilePaintPlan, type TilePaintSource, type TilesOptions };
+import { _ as PageViewDemand, a as PageRender, b as TilesOptions, c as RenderConfig, d as RenderPageOptions, f as RenderPagesOptions, g as FullPageOptions, h as RenderToken, i as PageLayerOptions, l as RenderFormat, m as RenderThumbnailOptions, n as InvalidateScope, o as RENDER_DEFAULTS, p as RenderSettings, r as PageImage, s as RenderCapability, t as InvalidateOptions, u as RenderInvalidatedEvent, x as samePageViewDemand } from "./contract-uc5nOice.js";
+export { type FullPageOptions, InvalidateOptions, InvalidateScope, PageImage, PageLayerOptions, PageRender, type PageViewDemand, type PageViewDemand as ViewDemandInput, RENDER_DEFAULTS, RenderCapability, RenderConfig, RenderFormat, RenderInvalidatedEvent, RenderPageOptions, RenderPagesOptions, RenderSettings, RenderThumbnailOptions, RenderToken, type TilesOptions, samePageViewDemand };

package/dist/contract.js

@@ -1,2 +1,2 @@
-import { t as RenderToken } from "./contract-BvwW7rrm.js";
-export { RenderToken };
+import { a as samePageViewDemand, n as RenderToken, t as RENDER_DEFAULTS } from "./contract-Dy5TiQDy.js";
+export { RENDER_DEFAULTS, RenderToken, samePageViewDemand };