mudlet-map-renderer 0.41.1-konva → 0.42.1-konva

package/dist/CullingManager.d.ts

@@ -1,78 +1,15 @@
 import { Settings } from './types/Settings';
-import { GroupNode, LayerNode } from './backend/DrawingBackend';
-export type CoordinateTransform = (x: number, y: number) => {
-    x: number;
-    y: number;
-};
-export type RoomNodeEntry = {
-    room: MapData.Room;
-    group: GroupNode;
-};
-type Bounds = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-export type StandaloneExitEntry = {
-    group: GroupNode;
-    bounds: Bounds;
-    targetRoomId?: number;
-};
-export type StageInfo = {
-    scaleX(): number;
-    position(): {
-        x: number;
-        y: number;
-    };
-    width(): number;
-    height(): number;
-};
-/**
- * Manages spatial indexing and viewport culling for rooms and exits.
- * Toggles node visibility based on what's in the viewport.
- * No direct Konva dependency.
- */
+import { CoordFn } from './coord/CoordFn';
 export declare class CullingManager {
-    private readonly stageInfo;
-    private readonly roomLayer;
-    private readonly linkLayer;
     private readonly settings;
-    roomNodes: Map<number, RoomNodeEntry>;
-    standaloneExitNodes: StandaloneExitEntry[];
-    spatialBucketSize: number;
-    private roomSpatialIndex;
-    private exitSpatialIndex;
-    private visibleRooms;
-    private visibleStandaloneExitNodes;
-    private bufferRoomSet;
-    private bufferExitSet;
-    private bufferRoomCandidates;
-    private bufferExitCandidates;
-    private standaloneExitBoundsRoomSize?;
+    private readonly onCullingNeeded;
     private cullingScheduled;
-    private perfMonitor;
     private coordinateTransform;
-    private lastGridMs;
-    constructor(stageInfo: StageInfo, roomLayer: LayerNode, linkLayer: LayerNode, settings: Settings);
-    setCoordinateTransform(fn: CoordinateTransform): void;
-    recordGridMs(ms: number): void;
-    private transformPoint;
-    private transformBounds;
-    computeBucketSize(): void;
-    clear(): void;
-    private getBucketKey;
-    private forEachBucket;
-    addRoomToSpatialIndex(entry: RoomNodeEntry): void;
-    addStandaloneExitToSpatialIndex(entry: StandaloneExitEntry): void;
-    findRoomAtMapPoint(mapX: number, mapY: number): MapData.Room | null;
-    markExitBoundsStale(): void;
-    setExitBoundsRoomSize(): void;
-    private collectRoomCandidates;
-    private collectStandaloneExitCandidates;
-    private refreshStandaloneExitBoundsIfNeeded;
+    constructor(settings: Settings, onCullingNeeded: () => void);
+    setCoordinateTransform(fn: CoordFn): void;
+    getCoordinateTransform(): CoordFn;
+    /** Schedule a cull pass on the next animation frame (no-op if already scheduled). */
     scheduleCulling(): void;
+    /** Run a cull pass immediately (used when mode changes). */
     updateCulling(): void;
-    private cullExits;
 }
-export {};

package/dist/InteractionHandler.d.ts

@@ -1,46 +1,30 @@
-import { Settings, RendererEventMap } from './types/Settings';
+import { RendererEventMap } from './types/Settings';
 import { TypedEventEmitter } from './TypedEventEmitter';
-import { Viewport } from './Viewport';
+import { Camera } from './camera/Camera';
 import { MapState } from './MapState';
-type Bounds = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-type AreaExitHitZone = {
-    bounds: Bounds;
-    targetRoomId: number;
-};
+import { HitResult } from './hit/HitTester';
 export type HitTestCallbacks = {
     clientToMapPoint: (clientX: number, clientY: number) => {
         x: number;
         y: number;
     } | null;
-    findRoomAtPoint: (mapX: number, mapY: number) => MapData.Room | null;
-    getAreaExitHitZones: () => AreaExitHitZone[];
     /**
-     * Inverse of the drawing backend's coordinate transform — maps a point from
-     * rendered space (what `clientToMapPoint` returns) back to untransformed map
-     * space. Needed for hit tests that compare against map-space bounds (e.g.
-     * area-exit hit zones) under decorators like IsometricStyle.
+     * Pick the topmost hit-annotated shape at a point in rendered space. The
+     * unified entry point for all DOM-level interaction — rooms, area-exit
+     * labels, and any future pickable kinds all flow through one query.
      */
-    renderedToMapPoint: (x: number, y: number) => {
-        x: number;
-        y: number;
-    };
+    pickAtPoint: (renderedX: number, renderedY: number) => HitResult | null;
 };
 /**
  * Handles all DOM interaction on the map container:
- * - Viewport: drag (mouse + touch), wheel zoom, pinch zoom, resize
+ * - Camera: drag (mouse + touch), wheel zoom, pinch zoom, resize
  * - Map: hover cursor, click, right-click, long-press, area exit clicks
  *
  * No Konva dependency — works with any rendering backend.
  */
 export declare class InteractionHandler {
     private readonly container;
-    private readonly settings;
-    private readonly viewport;
+    private readonly camera;
     private readonly state;
     private readonly hitTest;
     private readonly events;
@@ -49,17 +33,15 @@ export declare class InteractionHandler {
     private destroyed;
     /** Skip cursor changes when an external consumer (e.g. the editor) owns cursor management. */
     private setCursor;
-    constructor(container: HTMLDivElement, viewport: Viewport, state: MapState, settings: Settings, hitTest: HitTestCallbacks, events: TypedEventEmitter<RendererEventMap>);
+    constructor(container: HTMLDivElement, camera: Camera, state: MapState, hitTest: HitTestCallbacks, events: TypedEventEmitter<RendererEventMap>);
     destroy(): void;
     private listen;
     private initViewportEvents;
     private handlePinch;
     private initMapEvents;
-    private findRoomAtClientPoint;
-    private findAreaExitAtClientPoint;
+    private pickAtClientPoint;
     private emitRoomClickEvent;
     private emitRoomContextEvent;
     private emitAreaExitClickEvent;
     private emitMapClickEvent;
 }
-export {};

package/dist/ScenePipeline.d.ts

@@ -1,23 +1,31 @@
 import { default as MapReader } from './reader/MapReader';
 import { default as Area } from './reader/Area';
 import { default as Plane } from './reader/Plane';
-import { Settings, ViewportBounds } from './types/Settings';
-import { DrawingBackend, GroupNode, LayerNode } from './backend/DrawingBackend';
-import { RoomShapeRenderer } from './RoomShapeRenderer';
-import { GridRenderer } from './GridRenderer';
+import { Settings } from './types/Settings';
 import { default as ExitRenderer, ExitDrawData } from './ExitRenderer';
+import { GroupShape, Shape } from './scene/Shape';
 type Bounds = {
     x: number;
     y: number;
     width: number;
     height: number;
 };
-export type RoomNodeEntry = {
+/**
+ * Reference to one room's body shape inside the scene. Keyed by roomId so
+ * downstream consumers (cull index, hit-test bookkeeping) can find a room
+ * shape by id without re-walking the scene tree.
+ */
+export type RoomShapeRef = {
     room: MapData.Room;
-    group: GroupNode;
+    shape: GroupShape;
 };
-export type StandaloneExitEntry = {
-    group: GroupNode;
+/**
+ * Reference to one drawn link-exit shape, paired with its world-space bounds
+ * and (optional) cross-area target room. Used by the live renderer to hang
+ * cull entries on each exit.
+ */
+export type StandaloneExitShapeRef = {
+    shape: GroupShape;
     bounds: Bounds;
     targetRoomId?: number;
 };
@@ -91,44 +99,99 @@ export type DrawnStubEntry = {
     readonly stroke: string;
     readonly strokeWidth: number;
 };
+/**
+ * World-space shapes for each logical layer. Same content the backend layer
+ * nodes received, but as plain SceneIR data — consumed by exporters that drive
+ * {@link buildDrawCommands} → engine renderers without going through a
+ * {@link DrawingBackend}.
+ *
+ * Order within each list mirrors the order in which the corresponding layer
+ * node received its `addNode` calls: e.g. `link` is labels → link exits → for
+ * each room (special exits, stubs); `room` is rooms → area name → area-exit
+ * labels.
+ */
+export type SceneShapesByLayer = {
+    grid: Shape[];
+    link: Shape[];
+    room: Shape[];
+    topLabel: Shape[];
+};
+/** User-defined label shape paired with its world-space bounds (for culling). */
+export type LabelShapeRef = {
+    shape: GroupShape;
+    bounds: Bounds;
+};
+/** Custom-line (special-exit) shape paired with its world-space bounds (for culling). */
+export type SpecialExitShapeRef = {
+    shape: GroupShape;
+    bounds: Bounds;
+};
+/** Stub shape paired with its world-space bounds (for culling). */
+export type StubShapeRef = {
+    shape: GroupShape;
+    bounds: Bounds;
+};
+/** Area-exit label shape paired with its world-space bounds (for culling). */
+export type AreaExitLabelShapeRef = {
+    shape: GroupShape;
+    bounds: Bounds;
+};
 export type SceneBuildResult = {
-    roomNodes: Map<number, RoomNodeEntry>;
-    standaloneExitNodes: StandaloneExitEntry[];
+    /** Room body shapes keyed by roomId — for cull-entry construction. */
+    roomShapeRefs: Map<number, RoomShapeRef>;
+    /** Link-exit shapes paired with bounds and area-target metadata. */
+    standaloneExitShapeRefs: StandaloneExitShapeRef[];
+    /** Non-noScaling label shapes paired with world-space bounds (for culling). */
+    labelShapeRefs: LabelShapeRef[];
+    /** Custom-line special-exit shapes paired with world-space bounds (for culling). */
+    specialExitShapeRefs: SpecialExitShapeRef[];
+    /** Stub shapes paired with world-space bounds (for culling). */
+    stubShapeRefs: StubShapeRef[];
+    /** Area-exit label shapes paired with world-space bounds (for culling). */
+    areaExitLabelShapeRefs: AreaExitLabelShapeRef[];
     areaExitHitZones: AreaExitHitZone[];
     drawnExits: DrawnExitEntry[];
     drawnSpecialExits: DrawnSpecialExitEntry[];
     drawnStubs: DrawnStubEntry[];
+    /** World-space shapes carrying {@link HitInfo} annotations — fed to {@link HitTester}. */
+    hitShapes: Shape[];
+    /**
+     * Engine-agnostic shape lists per logical layer. Drives
+     * {@link buildDrawCommands} + a per-engine renderer.
+     */
+    sceneShapes: SceneShapesByLayer;
 };
 /**
- * Backend-agnostic scene composition pipeline.
- * Drives a DrawingBackend + LayerNode to render the full map scene.
+ * Engine-neutral scene composition pipeline.
+ *
+ * Walks a {@link MapData} area/plane and emits world-space {@link Shape}s per
+ * logical layer (grid / link / room / topLabel) plus the metadata downstream
+ * consumers need (cull entries, hit zones, drawn-geometry snapshots).
  *
- * Both the interactive KonvaRenderBackend and exporters (SvgExporter,
- * CanvasExporter, …) drive this pipeline with their respective DrawingBackend.
+ * The pipeline knows nothing about Konva, SVG, Canvas, or the
+ * {@link DrawCommandBuilder}: callers run the shape lists through whatever
+ * renderer fits their target. Both the interactive
+ * {@link KonvaRenderBackend} and the exporters consume the same
+ * {@link SceneBuildResult} this pipeline produces.
  */
 export declare class ScenePipeline {
     private readonly mapReader;
     private readonly settings;
-    private readonly backend;
-    readonly roomShapeRenderer: RoomShapeRenderer;
-    readonly gridRenderer: GridRenderer;
     readonly exitRenderer: ExitRenderer;
-    private readonly gridLayer;
-    private readonly linkLayer;
-    private readonly roomLayer;
-    private readonly topLabelLayer;
-    constructor(mapReader: MapReader, settings: Settings, backend: DrawingBackend, layers: {
-        gridLayer: LayerNode;
-        linkLayer: LayerNode;
-        roomLayer: LayerNode;
-        topLabelLayer?: LayerNode;
-    });
+    private linkShapes;
+    private roomShapes;
+    private topLabelShapes;
+    private labelShapeRefs;
+    private specialExitShapeRefs;
+    private stubShapeRefs;
+    private areaExitLabelShapeRefs;
+    constructor(mapReader: MapReader, settings: Settings);
     /**
      * Build the full scene for an area/plane.
      * Clears layers, renders grid → labels → exits → rooms → area name.
      * Returns data for culling and interaction (room nodes, exit data, hit zones).
      */
-    buildScene(area: Area, plane: Plane, zIndex: number, viewportBounds?: ViewportBounds): SceneBuildResult;
+    buildScene(area: Area, plane: Plane, zIndex: number): SceneBuildResult;
     getEffectiveBounds(area: Area, plane: Plane): {
         minX: number;
         maxX: number;
@@ -137,10 +200,12 @@ export declare class ScenePipeline {
     };
     private renderRooms;
     private renderLinkExits;
-    /** Render ExitDrawData through the DrawingBackend. */
-    renderExitData(data: ExitDrawData): GroupNode;
-    private renderArrow;
-    private targetLabelLayer;
+    /**
+     * Build the world-space shape tree for one inter-room exit. Used by the
+     * live renderer's current-room overlay path to recolour a single exit
+     * without rebuilding the whole scene.
+     */
+    buildExitShape(data: ExitDrawData): GroupShape;
     private renderLabels;
     private renderAreaExitLabels;
     private renderAreaName;

package/dist/camera/Camera.d.ts

@@ -0,0 +1,106 @@
+import { ViewportBounds } from '../types/Settings';
+import { TypedEventEmitter } from '../TypedEventEmitter';
+/** Pixels-per-world-unit at zoom = 1. Multiply by `Camera.zoom` for actual scale. */
+export declare const BASE_SCALE = 75;
+/** Events fired by {@link Camera}. */
+export type CameraEventMap = {
+    /** Any state change: zoom, pan, size, animation tick. */
+    change: void;
+};
+/**
+ * Engine-agnostic camera — owns transform state, drag, and animation.
+ *
+ * Subscribers ({@link KonvaRenderer}, {@link CullingManager}, {@link HitTester},
+ * scene overlays) listen to the `change` event to react to view updates.
+ *
+ * No Konva, no DOM. Only dependency is requestAnimationFrame (with a
+ * setTimeout fallback for Node.js).
+ */
+export declare class Camera extends TypedEventEmitter<CameraEventMap> {
+    zoom: number;
+    minZoom: number;
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    /** When true, resizing re-centers on the last panToMapPoint target. */
+    centerOnResize: boolean;
+    private dragging;
+    private dragStart;
+    private positionAtDragStart;
+    private animationId?;
+    constructor(width: number, height: number);
+    getScale(): number;
+    setZoom(zoom: number): boolean;
+    /** Zoom keeping the center of the viewport fixed. */
+    zoomToCenter(zoom: number): boolean;
+    /** Zoom keeping a specific screen point fixed (for mouse wheel zoom). */
+    zoomToPoint(zoom: number, screenX: number, screenY: number): boolean;
+    /** Bounds of the visible area in map space. */
+    getViewportBounds(): ViewportBounds;
+    /**
+     * Map-space bounds to use for culling. When `cullingBounds` is a
+     * screen-pixel sub-rect it is converted to map space via the current
+     * camera transform; otherwise the full viewport is returned.
+     */
+    getCullingViewport(cullingBounds?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null): ViewportBounds;
+    /**
+     * Create a Camera whose full viewport covers exactly the given world-space bounds.
+     * Used by headless exporters that need a Camera but have no real display.
+     */
+    static forMapBounds(minX: number, maxX: number, minY: number, maxY: number): Camera;
+    /**
+     * Create a Camera from an explicit render-camera transform (scale + offset).
+     * Used by {@link CanvasExporter} to derive culling bounds from the already-
+     * computed fitted transform without re-doing the letterbox math.
+     */
+    static forRenderCamera(width: number, height: number, scale: number, offsetX: number, offsetY: number): Camera;
+    /** Convert client/screen coordinates to map coordinates. */
+    clientToMapPoint(clientX: number, clientY: number, containerOffset?: {
+        left: number;
+        top: number;
+    }): {
+        x: number;
+        y: number;
+    } | null;
+    /** Center on a map coordinate, instantly. */
+    panToMapPoint(x: number, y: number): void;
+    /** Center on a map coordinate, with optional animation. */
+    panToMapPointAnimated(x: number, y: number, instant: boolean): void;
+    /**
+     * Compute the zoom level that would fit the given map bounds in the current
+     * viewport (with the same padding/insets as {@link fitToMapBounds}).
+     */
+    computeFitZoom(minX: number, maxX: number, minY: number, maxY: number, insets?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    }): number;
+    /**
+     * Fit the camera to show the given map bounds with padding.
+     * Optional `insets` (screen pixels) reserve space at each edge.
+     */
+    fitToMapBounds(minX: number, maxX: number, minY: number, maxY: number, insets?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    }): void;
+    setSize(width: number, height: number): void;
+    startDrag(screenX: number, screenY: number): void;
+    updateDrag(screenX: number, screenY: number): void;
+    endDrag(): void;
+    isDragging(): boolean;
+    private animate;
+    cancelAnimation(): void;
+    isAnimating(): boolean;
+    private notify;
+}

package/dist/coord/CoordFn.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Forward / inverse 2D coordinate transform. Used by camera-aware code that
+ * needs to translate between world space (the map's flat XY) and scene space
+ * (whatever the active style projects into — e.g. an isometric diamond).
+ *
+ * `IDENTITY_TRANSFORM` returns the input unchanged; flat styles (Parchment,
+ * Sketchy, plain identity) use it for both the forward and inverse direction.
+ */
+export type CoordFn = (x: number, y: number) => {
+    x: number;
+    y: number;
+};
+export declare const IDENTITY_TRANSFORM: CoordFn;

package/dist/draw/DrawCommand.d.ts

@@ -0,0 +1,104 @@
+import { LayerId } from '../scene/Shape';
+export interface RectCommand {
+    type: "rect";
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    fill?: string;
+    stroke?: string;
+    /** Stroke width in render units. */
+    sw: number;
+    /** Corner radius in render units. */
+    cr: number;
+    dash?: number[];
+}
+export interface CircleCommand {
+    type: "circle";
+    cx: number;
+    cy: number;
+    r: number;
+    fill?: string;
+    stroke?: string;
+    sw: number;
+    dash?: number[];
+}
+export interface LineCommand {
+    type: "line";
+    /** Flat list of [x0, y0, x1, y1, …] in render space. */
+    points: number[];
+    stroke?: string;
+    sw: number;
+    dash?: number[];
+    lineCap?: "butt" | "round" | "square";
+    lineJoin?: "miter" | "round" | "bevel";
+    /** 0..1 multiplier. */
+    alpha?: number;
+}
+export interface PolygonCommand {
+    type: "polygon";
+    vertices: number[];
+    fill?: string;
+    stroke?: string;
+    sw: number;
+}
+export interface TextCommand {
+    type: "text";
+    x: number;
+    y: number;
+    text: string;
+    fontSize: number;
+    fontFamily: string;
+    fontStyle: string;
+    fill: string;
+    stroke?: string;
+    /** Stroke width in render units (0 = no stroke). */
+    sw: number;
+    align: "left" | "center" | "right";
+    vAlign: "top" | "middle" | "bottom";
+    w: number;
+    h: number;
+    baselineRatio?: number;
+    konvaCorrectionRatio?: number;
+    transform?: [number, number, number, number, number, number];
+}
+export interface ImageCommand {
+    type: "image";
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    src: string;
+    transform?: [number, number, number, number, number, number];
+}
+/** Push an affine transform [a, b, c, d, e, f] onto the renderer's stack. */
+export interface PushTransformCommand {
+    type: "pushTransform";
+    matrix: [number, number, number, number, number, number];
+}
+/** Pop the most recent transform. */
+export interface PopTransformCommand {
+    type: "popTransform";
+}
+/** Push a clip rect; subsequent draws are clipped until matching pop. */
+export interface PushClipCommand {
+    type: "pushClip";
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface PopClipCommand {
+    type: "popClip";
+}
+export type PrimitiveDrawCommand = RectCommand | CircleCommand | LineCommand | PolygonCommand | TextCommand | ImageCommand;
+export type StackDrawCommand = PushTransformCommand | PopTransformCommand | PushClipCommand | PopClipCommand;
+export type DrawCommand = PrimitiveDrawCommand | StackDrawCommand;
+/**
+ * A bundle of commands targeting one logical layer. Renderers iterate layers
+ * in z-order and flush commands per layer.
+ */
+export interface DrawCommandBatch {
+    layer: LayerId;
+    commands: DrawCommand[];
+}

package/dist/draw/DrawCommandBuilder.d.ts

@@ -0,0 +1,19 @@
+import { DrawCommandBatch } from './DrawCommand';
+import { Shape } from '../scene/Shape';
+/** Camera state needed to project world coordinates into render space. */
+export interface CameraTransform {
+    /** Pixels per world unit. */
+    scale: number;
+    /** Render-space origin in pixels. */
+    offsetX: number;
+    offsetY: number;
+}
+/**
+ * Build per-layer {@link DrawCommandBatch}es from a list of world-space shapes
+ * and an active camera transform.
+ *
+ * Layer order in the result follows first-appearance order; renderers iterate
+ * the array as-is (z-order is the caller's responsibility — typically scene
+ * layout uses the LayerId taxonomy to pre-sort).
+ */
+export declare function buildDrawCommands(shapes: Shape[], camera: CameraTransform): DrawCommandBatch[];

package/dist/export/CanvasExporter.d.ts

@@ -24,20 +24,23 @@ export interface CanvasExportOptions {
     };
 }
 /**
- * Renders the current scene into a canvas at the requested width/height,
- * reframing the viewport to fit the area (or a specific room) with padding.
+ * Renders the current scene into a canvas at the requested width/height by
+ * driving {@link ScenePipeline} → {@link buildDrawCommands} →
+ * {@link renderToCanvas}.
  *
- * The returned {@link ExportCanvas} is the node-canvas-compatible object
- * produced by Konva. Serialize with `.toBuffer('image/png')` in Node or
- * `.toDataURL('image/png')` / `.toBlob(cb)` in the browser.
+ * Decoupled from the live Konva stage: the pipeline is rebuilt against the
+ * export bounds, shapes are projected through a fitted camera transform, and
+ * the result is rasterized onto a fresh 2D canvas. Background colour is
+ * filled before any draw commands replay, so PNG / JPEG output looks identical
+ * to the on-screen map.
  *
- * Unlike {@link PngExporter} (which rasterizes the current on-screen viewport),
- * `CanvasExporter` is the headless/programmatic path.
+ * Unlike {@link PngExporter} (which captures the on-screen viewport via the
+ * live Konva stage), `CanvasExporter` is fully headless and reproducible.
  */
 export declare class CanvasExporter implements Exporter<ExportCanvas | undefined> {
     private readonly options;
     constructor(options: CanvasExportOptions);
-    render({ backend }: ExportContext): ExportCanvas | undefined;
+    render({ state, style, sceneOverlays }: ExportContext): ExportCanvas | undefined;
 }
 export interface PngBytesExportOptions extends CanvasExportOptions {
     /** MIME type to encode. Defaults to `'image/png'`. */
@@ -62,6 +65,7 @@ export interface PngBytesExportOptions extends CanvasExportOptions {
  */
 export declare class PngBytesExporter implements Exporter<Uint8Array | undefined> {
     private readonly options;
+    private readonly canvasExporter;
     constructor(options: PngBytesExportOptions);
     render(context: ExportContext): Uint8Array | undefined;
 }

package/dist/export/Exporter.d.ts

@@ -1,5 +1,5 @@
 import { MapState } from '../MapState';
-import { Style } from '../backend/DrawingBackend';
+import { Style } from '../style/Style';
 import { SceneOverlay } from '../overlay/SceneOverlay';
 import { InteractiveBackend } from '../rendering/MapRenderer';
 /**
@@ -31,9 +31,10 @@ export interface Exporter<T> {
     render(context: ExportContext): T;
 }
 /**
- * Canvas returned by {@link InteractiveBackend.toCanvas} and
- * {@link CanvasExporter}. Describes the portable surface common to the
- * browser `HTMLCanvasElement` and the `canvas` package's Node-side Canvas:
+ * Canvas returned by {@link CanvasExporter} and
+ * {@link InteractiveBackend.exportCanvas}. Describes the portable surface
+ * common to the browser `HTMLCanvasElement` and the `canvas` package's
+ * Node-side Canvas:
  *
  *   - Portable:  `width`, `height`, `getContext`, `toDataURL`.
  *   - Browser:   `toBlob(cb)` (optional here; use when serializing to a Blob).

package/dist/export/SvgExporter.d.ts

@@ -1,15 +1,19 @@
 import { SvgExportOptions } from '../SvgTypes';
 import { Exporter, ExportContext } from './Exporter';
 /**
- * Renders the current scene as an SVG string through the shared
- * {@link ScenePipeline}. The context's style is applied so styled exports
- * match the on-screen canvas; {@link SceneOverlay}s from the context are
- * rendered into the SVG alongside the scene. `LiveEffect`s are intentionally
- * ignored by design.
+ * Renders the current scene as an SVG string by driving
+ * {@link ScenePipeline} → {@link buildDrawCommands} → {@link svgFromBatches}.
+ *
+ * The pipeline is rebuilt with bounded viewport bounds (so the grid layout
+ * matches the export region), then `sceneShapes` is flushed through the
+ * draw-command pipeline at scale 1 — coordinates land inside the SVG
+ * viewBox in world space, identical to the legacy SvgBackend output. Active
+ * {@link SceneOverlay}s are still rendered against an {@link SvgBackend}
+ * so user code that builds custom overlays via the DrawingBackend keeps
+ * working until the overlay API is migrated to shapes.
  */
 export declare class SvgExporter implements Exporter<string | undefined> {
     private readonly options;
     constructor(options?: SvgExportOptions);
     render({ state, style, sceneOverlays }: ExportContext): string | undefined;
-    private renderBuiltInOverlays;
 }