@overtone-art/canvas-editor-core 0.2.6 → 0.2.8

package/dist/index.d.mts

@@ -1,221 +1,6 @@
-import { FabricObject, Canvas, ImageFormat } from 'fabric';
-
-type Unit = 'px' | 'mm' | 'in';
-type LayerType = 'image' | 'text' | 'shape' | 'template' | 'group';
-interface LayerData {
-    id: string;
-    type: LayerType;
-    name: string;
-    visible: boolean;
-    locked: boolean;
-    opacity: number;
-    /** Non-fabric metadata persisted with the layer (pattern config, etc). */
-    meta?: LayerMeta;
-}
-interface LayerMeta {
-    pattern?: PatternState;
-    [key: string]: unknown;
-}
-interface SerializedLayer extends LayerData {
-    fabricObject: Record<string, unknown>;
-}
-interface EditorState {
-    version: string;
-    canvas: {
-        width: number;
-        height: number;
-    };
-    layers: SerializedLayer[];
-    background?: string;
-    mockup?: MockupConfig | null;
-}
-interface EditorConfig {
-    width: number;
-    height: number;
-    backgroundColor?: string;
-    fileAdapter?: FileAdapter;
-    imageProvider?: ImageProvider;
-    preserveObjectStacking?: boolean;
-    unit?: Unit;
-    dpi?: number;
-}
-type ExportFormat = 'png' | 'svg' | 'json';
-interface FileAdapter {
-    save(data: Blob | string, filename: string, format: ExportFormat): Promise<string>;
-}
-interface ImageProviderResult {
-    url: string;
-    width: number;
-    height: number;
-}
-interface ImageProvider {
-    upload(file: File): Promise<ImageProviderResult>;
-    browse?(): Promise<ImageProviderResult | null>;
-}
-interface ShapePlugin {
-    name: string;
-    icon: string;
-    category?: string;
-    create(options?: Record<string, unknown>): FabricObject;
-}
-interface TemplateParameter {
-    key: string;
-    label: string;
-    type: 'text' | 'color' | 'number' | 'font';
-    default: string | number;
-}
-interface TemplateDefinition {
-    id: string;
-    name: string;
-    category: string;
-    svg: string;
-    parameters: TemplateParameter[];
-    preview?: string;
-}
-interface PrintifyPositioning {
-    x: number;
-    y: number;
-    scale: number;
-    angle: number;
-}
-type TileMode = 'grid' | 'brick-horizontal' | 'brick-vertical';
-interface PatternConfig {
-    mode: TileMode;
-    /**
-     * Tile size as a % of the source image's on-canvas size (100 = natural).
-     * Smaller values pack more repeats across the print area; larger values make
-     * fewer, bigger tiles. Independent of how the source layer was placed.
-     */
-    scale: number;
-    /** Extra horizontal gap between tiles, as % of tile width. */
-    horizontalSpacing: number;
-    /** Extra vertical gap between tiles, as % of tile height. */
-    verticalSpacing: number;
-    /** Rotation of the whole pattern, in degrees. */
-    angle: number;
-    /** Brick row/column shift, as % of tile size. */
-    horizontalOffset: number;
-    /**
-     * Phase shift of the whole tile grid inside the print area, as % of tile
-     * width. The pattern object itself is pinned to the print area (it can't be
-     * dragged — that would expose bare edges), so this is how the tiling is
-     * nudged into alignment. Clamped to ±100% so coverage is never broken.
-     */
-    offsetX: number;
-    /** Phase shift of the tile grid, as % of tile height. See {@link offsetX}. */
-    offsetY: number;
-    /** Added rotation per horizontal step, in degrees. */
-    rotationStepH: number;
-    /** Added rotation per vertical step, in degrees. */
-    rotationStepV: number;
-}
-/** Fabric interaction flags frozen while a layer is rendered as a pattern. */
-interface PatternLocks {
-    lockMovementX: boolean;
-    lockMovementY: boolean;
-    lockScalingX: boolean;
-    lockScalingY: boolean;
-    lockRotation: boolean;
-    hasControls: boolean;
-}
-/** Persisted on a layer's meta while it is rendered as a repeating pattern. */
-interface PatternState {
-    config: PatternConfig;
-    /** Original (pre-pattern) image source, as a durable data URL when possible. */
-    originalSrc: string;
-    /**
-     * Serialized `clipPath` the image carried before it became a pattern, or null
-     * if it had none. A pattern must fill the whole print area, so any pre-pattern
-     * clip (e.g. a template crop sized to the original box) is stripped while the
-     * pattern is on and re-applied when it is turned off. Persisted so it survives
-     * serialization / reload / undo.
-     */
-    originalClip?: Record<string, unknown> | null;
-    /**
-     * Interaction flags the object carried before it became a pattern. A pattern
-     * fills the whole print area, so while it is on the object is locked in place
-     * (a drag/resize would slide the tiled bitmap off the area and leave a bare
-     * band); the captured flags are restored when the pattern is turned off.
-     */
-    originalLocks?: PatternLocks;
-    /** Original fabric transform, restored when the pattern is turned off. */
-    original: {
-        left: number;
-        top: number;
-        scaleX: number;
-        scaleY: number;
-        width: number;
-        height: number;
-        angle: number;
-        cropX: number;
-        cropY: number;
-    };
-}
-declare const DEFAULT_PATTERN_CONFIG: PatternConfig;
-interface MockupPrintArea {
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-}
-interface MockupConfig {
-    /** Garment/product image rendered behind the design (preview only). */
-    image: string;
-    /** Print-area rectangle, in canvas pixels. Drawn as a guide. */
-    printArea?: MockupPrintArea;
-}
-interface EditorEvents {
-    'layer:added': {
-        layer: LayerData;
-    };
-    'layer:removed': {
-        layerId: string;
-    };
-    'layer:selected': {
-        layerId: string | null;
-    };
-    'layer:modified': {
-        layerId: string;
-    };
-    'layer:reordered': {
-        layerIds: string[];
-    };
-    'layers:changed': {
-        layers: LayerData[];
-    };
-    'selection:changed': {
-        selected: string[];
-    };
-    'history:changed': {
-        canUndo: boolean;
-        canRedo: boolean;
-    };
-    'zoom:changed': {
-        zoom: number;
-    };
-    'snap:changed': {
-        enabled: boolean;
-    };
-    'crop:changed': {
-        active: boolean;
-        layerId: string | null;
-    };
-    'mockup:changed': {
-        mockup: MockupConfig | null;
-    };
-    'canvas:modified': Record<string, never>;
-    'export:start': {
-        format: string;
-    };
-    'export:complete': {
-        format: string;
-        url?: string;
-    };
-    error: {
-        message: string;
-        error?: unknown;
-    };
-}
+import { Canvas, FabricObject, ImageFormat } from 'fabric';
+import { b as EditorEvents, l as LayerType, k as LayerMeta, L as LayerData, U as SerializedLayer, G as PatternSourceResolver, P as PatternConfig, A as PatternLocks, _ as Unit, z as MockupPrintArea, v as MockupConfig, e as FontDefinition, m as LicenseConfig, o as LicenseStatus, Q as ProjectState, M as MaskBrushOptions, p as MaskPoint, r as MaskRefinementProvider, q as MaskRefinementPrompt, t as MaskRefinementResult, E as EditorConfig, V as ShapePlugin, X as TemplateDefinition, I as ImageAdjustments, c as EditorState, S as SemanticExportOptions, W as SvgExportOptions, K as PrintifyPositioning, N as NormalizedLayerPosition, J as PositioningAdapter, h as ImageProviderResult, i as ImageSearchOptions, j as ImageSearchResult, F as FileAdapter, g as ImageProvider, T as SerializedBackgroundImageOptions, B as BackgroundImageOptions, R as ResizeOptions, a as DpiIssue, C as CanvasSizePreset, w as MockupDisplacement } from './types-D60CfxL9.mjs';
+export { D as DEFAULT_PATTERN_CONFIG, d as ExportFormat, f as ImageAttribution, n as LicensePayload, s as MaskRefinementRequest, u as MockupBlendMode, x as MockupDisplacementChannel, y as MockupOverlay, H as PatternState, O as ProjectPage, Y as TemplateParameter, Z as TileMode } from './types-D60CfxL9.mjs';
 
 type EventHandler<T> = (data: T) => void;
 declare class EventEmitter<TEvents extends {} = Record<string, unknown>> {
@@ -236,7 +21,7 @@ declare class Layer {
     opacity: number;
     /** Non-fabric data (e.g. pattern config) that must persist with the layer. */
     meta: LayerMeta;
-    readonly fabricObject: FabricObject;
+    fabricObject: FabricObject;
     constructor(type: LayerType, fabricObject: FabricObject, name?: string, id?: string);
     private hasMeta;
     toData(): LayerData;
@@ -246,9 +31,13 @@ declare class LayerManager {
     private canvas;
     private events;
     private layers;
+    private onPropertyChanged?;
     constructor(canvas: Canvas, events: EventEmitter<EditorEvents>);
+    setHistoryCallback(callback: () => void): void;
     add(type: LayerType, fabricObject: FabricObject, name?: string, id?: string): Layer;
     remove(id: string): boolean;
+    /** Replace a layer's render object while preserving its immutable ID and panel state. */
+    replaceObject(id: string, fabricObject: FabricObject): boolean;
     reorder(id: string, newIndex: number): boolean;
     select(id: string | null): void;
     get(id: string): Layer | undefined;
@@ -264,24 +53,35 @@ declare class LayerManager {
 }
 
 declare class HistoryManager {
+    private static readonly ASSET_KEY;
     private undoStack;
     private redoStack;
+    private assets;
+    private assetIds;
+    private nextAssetId;
     private maxSize;
+    private maxBytes;
     private paused;
     private debounceTimer;
     private debounceMs;
     private getState;
     private restoreState;
     private events;
+    private transactionDepth;
+    private transactionDirty;
     constructor(opts: {
         getState: () => string;
         restoreState: (state: string) => Promise<void>;
         events: EventEmitter<EditorEvents>;
         maxSize?: number;
+        maxBytes?: number;
         debounceMs?: number;
     });
     save(): void;
     saveImmediate(): void;
+    beginTransaction(): void;
+    endTransaction(): void;
+    transaction<T>(operation: () => T | Promise<T>): Promise<T>;
     undo(): Promise<void>;
     redo(): Promise<void>;
     /** True while a restore (undo/redo/deserialize) is in flight. Managers that
@@ -292,9 +92,27 @@ declare class HistoryManager {
     canUndo(): boolean;
     canRedo(): boolean;
     clear(): void;
+    getSnapshotBytes(): number;
     private cancelPending;
     dispose(): void;
     private emitChanged;
+    private snapshotBytes;
+    private trimToBudget;
+    /**
+     * History is internal and can content-address large raster strings without
+     * changing the public EditorState wire format. Unchanged images are retained
+     * once even when dozens of snapshots reference them.
+     */
+    private compactState;
+    private expandState;
+    /**
+     * Runs on every commit, so it scans for the serialized reference marker
+     * instead of re-parsing every snapshot — parsing multi-megabyte raster states
+     * per save would cost more than the retention it reclaims. `JSON.stringify`
+     * emits the marker verbatim; the same text inside user data is escaped and
+     * therefore cannot match.
+     */
+    private pruneAssets;
 }
 
 /**
@@ -357,8 +175,10 @@ declare class PatternManager {
     private canvas;
     private layers;
     private history;
+    private events;
+    private sourceResolver?;
     private chains;
-    constructor(canvas: Canvas, layers: LayerManager, history: HistoryManager);
+    constructor(canvas: Canvas, layers: LayerManager, history: HistoryManager, events: EventEmitter<EditorEvents>, sourceResolver?: PatternSourceResolver | undefined);
     isPattern(layerId: string): boolean;
     getConfig(layerId: string): PatternConfig | null;
     /** Turn a plain image layer into a pattern, or update an existing one. */
@@ -388,6 +208,7 @@ declare function applyPatternLocks(obj: FabricObject): void;
  * leaving it frozen forever.
  */
 declare function restoreLocks(obj: FabricObject, locks: PatternLocks | undefined): void;
+declare function loadPatternImage(src: string, resolver?: PatternSourceResolver): Promise<HTMLImageElement>;
 /** Clear the decoded-image cache (e.g. on teardown). Exported for completeness. */
 declare function clearPatternImageCache(): void;
 /**
@@ -396,7 +217,7 @@ declare function clearPatternImageCache(): void;
  *
  * Exported for unit testing of the tile geometry.
  */
-declare function buildPatternDataURL(src: string, config: PatternConfig, targetW: number, targetH: number, baseW: number, baseH: number): Promise<string>;
+declare function buildPatternDataURL(src: string, config: PatternConfig, targetW: number, targetH: number, baseW: number, baseH: number, sourceResolver?: PatternSourceResolver): Promise<string>;
 /** Placement of one tile, relative to the (already rotated) pattern centre. */
 interface TilePlacement {
     /** Tile-centre offset from the pattern centre, in px. */
@@ -442,10 +263,124 @@ interface PngExportOptions {
     format?: ImageFormat;
     quality?: number;
 }
+interface CoverPlacement {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+declare function computePrintAreaClip(area: MockupPrintArea, scaleX: number, scaleY: number, targetWidth: number, targetHeight: number): MockupPrintArea;
+/** Object-fit: cover geometry, exported for deterministic preview/composite tests. */
+declare function computeCoverPlacement(sourceWidth: number, sourceHeight: number, targetWidth: number, targetHeight: number): CoverPlacement;
 declare function exportPNG(canvas: Canvas, options?: PngExportOptions): Promise<Blob>;
+/** Rasterize the browser mockup preview together with the transparent design. */
+declare function exportMockup(canvas: Canvas, mockup: MockupConfig, options?: PngExportOptions): Promise<Blob>;
 declare function exportSVG(canvas: Canvas): string;
 declare function exportDataURL(canvas: Canvas, format?: ImageFormat, multiplier?: number): string;
 
+/** Browser font loader and SVG embedding registry. */
+declare class FontRegistry {
+    private definitions;
+    private loads;
+    register(definition: FontDefinition): void;
+    unregister(family: string): boolean;
+    getAll(): FontDefinition[];
+    load(family: string): Promise<FontFace>;
+    ready(): Promise<void>;
+    getEmbeddedCss(): Promise<string>;
+}
+
+/** Inert, honor-system licensing and usage seam; it never performs a network request. */
+declare class LicenseManager {
+    private config;
+    private status;
+    private readyPromise;
+    constructor(config?: LicenseConfig);
+    getStatus(): LicenseStatus;
+    ready(): Promise<LicenseStatus>;
+    hasFeature(feature: string): boolean;
+    track(name: string): void;
+    private validate;
+}
+
+/** Multi-page document state bound to one live editor canvas. */
+declare class ProjectManager {
+    private editor;
+    private pages;
+    private activePageId;
+    constructor(editor: CanvasEditor);
+    getAll(): Array<{
+        id: string;
+        name: string;
+    }>;
+    getActivePageId(): string;
+    add(name?: string, cloneCurrent?: boolean): string;
+    switchTo(id: string): Promise<boolean>;
+    duplicate(id: string): Promise<string | null>;
+    remove(id: string): Promise<boolean>;
+    rename(id: string, name: string): boolean;
+    reorder(id: string, newIndex: number): boolean;
+    toJSON(): ProjectState;
+    fromJSON(project: ProjectState): Promise<void>;
+    private saveCurrent;
+    private blankState;
+    private emitChanged;
+}
+
+type MaskRefinementErrorCode = 'not-found' | 'cancelled' | 'provider' | 'invalid-result';
+declare class MaskRefinementError extends Error {
+    readonly code: MaskRefinementErrorCode;
+    readonly cause?: unknown | undefined;
+    constructor(code: MaskRefinementErrorCode, message: string, cause?: unknown | undefined);
+}
+interface MaskPerformanceSample {
+    width: number;
+    height: number;
+    backingBytes: number;
+    strokeBackupBytes: number;
+    estimatedPeakBytes: number;
+    historyBytes: number;
+    interactionLatencyMs: number;
+    usedJsHeapBytes?: number;
+    elapsedMs: number;
+}
+/** Raster-mask editing without exposing Fabric brush classes in the public contract. */
+declare class MaskController {
+    private readonly editor;
+    private backing;
+    private context;
+    private layerId;
+    private brush;
+    private previousPoint;
+    private strokeBackup;
+    private strokeStartedAt;
+    private lastInteractionLatencyMs;
+    private refinement;
+    private disposed;
+    constructor(editor: CanvasEditor);
+    create(width?: number, height?: number): Promise<Layer>;
+    attach(layerId: string): void;
+    beginStroke(options: MaskBrushOptions): void;
+    addPoint(point: MaskPoint): void;
+    endStroke(): Promise<void>;
+    cancelStroke(): void;
+    isStrokeActive(): boolean;
+    activeLayerId(): string | null;
+    detach(layerId?: string): void;
+    refine(layerId: string, provider: MaskRefinementProvider, prompts: MaskRefinementPrompt[], options?: {
+        signal?: AbortSignal;
+        onProgress?: (progress: number) => void;
+    }): Promise<MaskRefinementResult>;
+    cancelRefinement(): void;
+    measure(): MaskPerformanceSample | null;
+    dispose(): void;
+    private drawDot;
+    private makeCanvas;
+    private attachBacking;
+    private requireMask;
+    private assertActive;
+}
+
 declare class CanvasEditor {
     readonly canvas: Canvas;
     readonly layers: LayerManager;
@@ -455,16 +390,24 @@ declare class CanvasEditor {
     readonly snapping: SnapManager;
     readonly crop: CropController;
     readonly patterns: PatternManager;
+    readonly fonts: FontRegistry;
+    readonly licensing: LicenseManager;
+    readonly pages: ProjectManager;
+    readonly masks: MaskController;
     private fileAdapter?;
     private imageProvider?;
     private zoomLevel;
     private mockup;
     private designBackground;
+    private designBackgroundImage;
+    private backgroundImageOptions;
     constructor(canvasElement: HTMLCanvasElement, config: EditorConfig);
     addImage(url: string, options?: Partial<Record<string, unknown>>): Promise<Layer>;
+    /** Replace an image source without changing its layer identity or visual transform. */
+    replaceImageSource(layerId: string, url: string): Promise<Layer>;
     addText(text: string, options?: Partial<Record<string, unknown>>): Layer;
     addShape(plugin: ShapePlugin, options?: Record<string, unknown>): Layer;
-    addTemplate(template: TemplateDefinition, _params: Record<string, string | number>): Promise<Layer>;
+    addTemplate(template: TemplateDefinition, params: Record<string, string | number>): Promise<Layer>;
     removeLayer(id: string): void;
     selectLayer(id: string | null): void;
     getSelectedLayer(): Layer | null;
@@ -472,11 +415,26 @@ declare class CanvasEditor {
     flipLayer(id: string, axis: 'horizontal' | 'vertical'): void;
     /** Clone a layer (offset slightly) and select the copy. */
     duplicateLayer(id: string): Promise<Layer | null>;
+    applyImageAdjustments(layerId: string, adjustments: ImageAdjustments): boolean;
+    /** Combine two or more layers into a single editable group layer. */
+    groupLayers(ids: string[], name?: string): Promise<Layer | null>;
+    /** Restore a group created by groupLayers back to its original layer records. */
+    ungroupLayer(id: string): Promise<Layer[]>;
     toJSON(): EditorState;
     fromJSON(state: EditorState): Promise<void>;
     toPNG(options?: PngExportOptions): Promise<Blob>;
+    toJPEG(options?: Omit<PngExportOptions, 'format'>): Promise<Blob>;
+    toWebP(options?: Omit<PngExportOptions, 'format'>): Promise<Blob>;
+    /** Export one layer in document coordinates or at its native image resolution. */
+    exportLayer(id: string, options?: SemanticExportOptions): Promise<Blob>;
+    /** Export only the configured document background, excluding design layers. */
+    exportBackground(options?: SemanticExportOptions): Promise<Blob>;
+    private toRaster;
     toSVG(): string;
+    toSVGAsync(options?: SvgExportOptions): Promise<string>;
     toDataURL(format?: ImageFormat, multiplier?: number): string;
+    /** Export the current product-preview composite. Advanced warping is host-defined. */
+    toMockupImage(options?: PngExportOptions): Promise<Blob>;
     /**
      * Run an export with the configured design background applied, even when a
      * mockup preview has forced the live canvas transparent — so exports reflect
@@ -484,14 +442,35 @@ declare class CanvasEditor {
      */
     private withDesignBackground;
     toPrintifyPositioning(): Record<string, PrintifyPositioning>;
-    save(filename: string, format: 'png' | 'svg' | 'json'): Promise<string | undefined>;
+    /** Provider-neutral, ID-stable placement data in 0..1 canvas coordinates. */
+    toNormalizedPositioning(): NormalizedLayerPosition[];
+    toProviderPositioning<T>(adapter: PositioningAdapter<T>): T;
+    save(filename: string, format: 'png' | 'jpeg' | 'webp' | 'svg' | 'json'): Promise<string | undefined>;
     uploadImage(file: File): Promise<ImageProviderResult | undefined>;
     browseImages(): Promise<ImageProviderResult | null>;
+    searchImages(query: string, options?: ImageSearchOptions): Promise<ImageSearchResult | null>;
+    /** Track provider usage, then insert its hotlinked image as a normal layer. */
+    addProviderImage(image: ImageProviderResult, options?: Partial<Record<string, unknown>>): Promise<Layer>;
     setFileAdapter(adapter: FileAdapter): void;
     setImageProvider(provider: ImageProvider): void;
     setBackground(color: string): void;
     getDesignBackground(): string;
-    resize(width: number, height: number): void;
+    getDesignBackgroundImage(): FabricObject | null;
+    getBackgroundImageOptions(): SerializedBackgroundImageOptions | null;
+    setBackgroundImage(url: string | null, options?: BackgroundImageOptions): Promise<void>;
+    /** Used by state restoration and advanced integrations with an existing Fabric object. */
+    setBackgroundImageObject(image: FabricObject | null, save?: boolean, options?: SerializedBackgroundImageOptions | null): void;
+    setTransparentBackground(): void;
+    resize(width: number, height: number, options?: ResizeOptions): void;
+    /** Effective source resolution for an image at its current physical size. */
+    getImageDpi(layerId: string): number | null;
+    validateImageDpi(minimumDpi?: number): DpiIssue[];
+    /** Render a small data-URL preview without changing document dimensions. */
+    toThumbnail(maxWidth?: number, maxHeight?: number, format?: ImageFormat): string;
+    bringToFront(id: string): boolean;
+    sendToBack(id: string): boolean;
+    bringForward(id: string): boolean;
+    sendBackward(id: string): boolean;
     setZoom(level: number): void;
     /** @deprecated use setZoom — kept for backward compatibility. */
     zoom(level: number): void;
@@ -501,6 +480,8 @@ declare class CanvasEditor {
     resetZoom(): void;
     /** Fit the canvas inside a viewport (in px), accounting for padding. */
     zoomToFit(viewportWidth: number, viewportHeight: number, padding?: number): void;
+    /** Zoom until the current selection fills the artboard viewport. */
+    zoomToSelection(padding?: number): void;
     applyPattern(layerId: string, config: PatternConfig): Promise<void>;
     clearPattern(layerId: string): Promise<void>;
     setMockup(mockup: MockupConfig | null): void;
@@ -515,7 +496,98 @@ declare const generateId: () => string;
 declare function clamp(v: number, min: number, max: number): number;
 declare function round2(v: number): number;
 
+/** XML text/attribute escaping for values interpolated into an SVG document. */
+declare function escapeXml(value: string | number): string;
+/**
+ * Strip active and externally-loaded content from an SVG before it is parsed
+ * into canvas objects.
+ *
+ * This is the single implementation of the control — every path that turns
+ * untrusted SVG into layers must call it, so it is exported rather than
+ * re-declared per package.
+ */
+declare function sanitizeSvg(svg: string): string;
+
+/** True for values safe to use as a canvas/SVG colour. Empty means transparent. */
+declare function isCssColor(value: unknown, allowEmpty?: boolean): value is string;
+
 declare function serializeEditor(editor: CanvasEditor): EditorState;
 declare function deserializeEditor(editor: CanvasEditor, state: EditorState): Promise<void>;
 
-export { CanvasEditor, CropController, DEFAULT_PATTERN_CONFIG, type EditorConfig, type EditorEvents, type EditorState, EventEmitter, type ExportFormat, type FileAdapter, HistoryManager, type ImageProvider, type ImageProviderResult, Layer, type LayerData, LayerManager, type LayerMeta, type LayerType, type MockupConfig, type MockupPrintArea, type PatternConfig, type PatternLocks, PatternManager, type PatternState, type PngExportOptions, type PrintifyPositioning, type SerializedLayer, type ShapePlugin, SnapManager, type TemplateDefinition, type TemplateParameter, type TileMode, type TilePlacement, type Unit, UnitConverter, applyPatternLocks, buildPatternDataURL, captureLocks, clamp, clearPatternImageCache, computeTilePositions, deserializeEditor, drawTiles, exportDataURL, exportPNG, exportSVG, generateId, restoreLocks, round2, serializeEditor };
+/** Common print and digital canvas sizes. */
+declare const CANVAS_SIZE_PRESETS: readonly CanvasSizePreset[];
+
+type AnnotationPrimitive = {
+    id: string;
+    type: 'point';
+    x: number;
+    y: number;
+    label?: string;
+} | {
+    id: string;
+    type: 'rectangle';
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    label?: string;
+} | {
+    id: string;
+    type: 'label';
+    x: number;
+    y: number;
+    text: string;
+} | {
+    id: string;
+    type: 'path';
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+    label?: string;
+};
+interface ViewportTransform {
+    zoom: number;
+    panX: number;
+    panY: number;
+    devicePixelRatio?: number;
+}
+/** Host-owned annotations that never enter editor layers, history, serialization, or exports. */
+declare class AnnotationOverlay {
+    private items;
+    private transform;
+    set(annotation: AnnotationPrimitive): void;
+    remove(id: string): boolean;
+    clear(): void;
+    getAll(): AnnotationPrimitive[];
+    setTransform(transform: ViewportTransform): void;
+    documentToViewport(point: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    viewportToDocument(point: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    documentToDevice(point: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+}
+
+/**
+ * Warp RGBA pixels with an equally sized channel map. A channel value of 128
+ * is neutral; 0 and 255 move by the configured negative/positive maximum.
+ */
+declare function displaceRgba(source: Uint8ClampedArray, map: Uint8ClampedArray, width: number, height: number, options: Omit<MockupDisplacement, 'image'>): Uint8ClampedArray;
+
+export { AnnotationOverlay, type AnnotationPrimitive, BackgroundImageOptions, CANVAS_SIZE_PRESETS, CanvasEditor, CanvasSizePreset, type CoverPlacement, CropController, DpiIssue, EditorConfig, EditorEvents, EditorState, EventEmitter, FileAdapter, FontDefinition, FontRegistry, HistoryManager, ImageAdjustments, ImageProvider, ImageProviderResult, ImageSearchOptions, ImageSearchResult, Layer, LayerData, LayerManager, LayerMeta, LayerType, LicenseConfig, LicenseManager, LicenseStatus, MaskBrushOptions, MaskController, type MaskPerformanceSample, MaskPoint, MaskRefinementError, type MaskRefinementErrorCode, MaskRefinementPrompt, MaskRefinementProvider, MaskRefinementResult, MockupConfig, MockupDisplacement, MockupPrintArea, NormalizedLayerPosition, PatternConfig, PatternLocks, PatternManager, PatternSourceResolver, type PngExportOptions, PositioningAdapter, PrintifyPositioning, ProjectManager, ProjectState, ResizeOptions, SemanticExportOptions, SerializedBackgroundImageOptions, SerializedLayer, ShapePlugin, SnapManager, SvgExportOptions, TemplateDefinition, type TilePlacement, Unit, UnitConverter, type ViewportTransform, applyPatternLocks, buildPatternDataURL, captureLocks, clamp, clearPatternImageCache, computeCoverPlacement, computePrintAreaClip, computeTilePositions, deserializeEditor, displaceRgba, drawTiles, escapeXml, exportDataURL, exportMockup, exportPNG, exportSVG, generateId, isCssColor, loadPatternImage, restoreLocks, round2, sanitizeSvg, serializeEditor };