@kritzel/engine 0.4.31

package/dist/types/classes/objects/shape.class.d.ts

@@ -0,0 +1,322 @@
+import { KritzelBaseObject } from './base-object.class';
+import { KritzelCore } from '../core/core.class';
+import { ShapeType } from '../../enums/shape-type.enum';
+import { KritzelPoint } from '../../interfaces/point.interface';
+import { EditorView } from 'prosemirror-view';
+import { ThemeAwareColor } from '../../constants/color-palette.constants';
+import { KritzelObjectExportContext, KritzelObjectExportFormat } from '../../interfaces/object-export.interface';
+/**
+ * Configuration options for creating a KritzelShape instance.
+ */
+export interface KritzelShapeConfig {
+    x?: number;
+    y?: number;
+    translateX?: number;
+    translateY?: number;
+    rotation?: number;
+    width?: number;
+    height?: number;
+    shapeType?: ShapeType;
+    fillColor?: ThemeAwareColor;
+    strokeColor?: ThemeAwareColor;
+    strokeWidth?: number;
+    fontSize?: number;
+    fontFamily?: string;
+    fontColor?: ThemeAwareColor;
+    scale?: number;
+    scaleX?: number;
+    scaleY?: number;
+}
+export declare class KritzelShape extends KritzelBaseObject<HTMLDivElement> {
+    __class__: string;
+    shapeType: ShapeType;
+    fillColor: ThemeAwareColor;
+    strokeColor: ThemeAwareColor;
+    strokeWidth: number;
+    fontFamily: string;
+    fontSize: number;
+    fontColor: ThemeAwareColor;
+    /** Screen-space x coordinate of the shape's top-left corner (like Path.x) */
+    x: number;
+    /** Screen-space y coordinate of the shape's top-left corner (like Path.y) */
+    y: number;
+    scale?: number;
+    scaleFactor: number;
+    isDebugInfoVisible: boolean;
+    isEditable: boolean;
+    isEditing: boolean;
+    editor: EditorView | null;
+    content: any;
+    private readonly _schema;
+    uneditedObject: KritzelShape | null;
+    /**
+     * Returns the viewBox for the shape's SVG, using screen-space coordinates.
+     * This follows the same pattern as KritzelPath.viewBox.
+     */
+    get viewBox(): string;
+    /**
+     * Creates a new KritzelShape instance with optional configuration.
+     * This constructor initializes the shape with default values that can be
+     * overridden by the provided configuration object.
+     *
+     * @param config - Optional configuration object for the shape
+     * @param config.x - Screen-space x coordinate of the shape's top-left corner
+     * @param config.y - Screen-space y coordinate of the shape's top-left corner
+     * @param config.translateX - World-space x translation offset
+     * @param config.translateY - World-space y translation offset
+     * @param config.width - Width of the shape in screen-space pixels
+     * @param config.height - Height of the shape in screen-space pixels
+     * @param config.shapeType - Type of shape (Rectangle, Ellipse, Triangle)
+     * @param config.fillColor - Theme-aware fill color with light and dark variants
+     * @param config.strokeColor - Theme-aware stroke color with light and dark variants
+     * @param config.strokeWidth - Width of the shape's stroke in pixels
+     * @param config.fontSize - Font size for text content in points
+     * @param config.fontFamily - Font family for text content
+     * @param config.fontColor - Theme-aware font color (auto-determined from fillColor if not specified)
+     * @param config.scale - Viewport scale factor at creation time
+     * @param config.scaleX - Horizontal scale factor for transformations
+     * @param config.scaleY - Vertical scale factor for transformations
+     */
+    constructor(config?: KritzelShapeConfig);
+    /**
+     * Creates a new KritzelShape with screen-space coordinates.
+     * Following the same pattern as KritzelPath.create():
+     * - x, y are screen-space coordinates of the shape's top-left corner
+     * - translateX, translateY should be set to -viewportTranslateX, -viewportTranslateY
+     * - width, height are in screen-space
+     * - scale is the viewport scale at creation time
+     */
+    static create(core: KritzelCore, config?: {
+        x?: number;
+        y?: number;
+        translateX?: number;
+        translateY?: number;
+        rotation?: number;
+        width?: number;
+        height?: number;
+        shapeType?: ShapeType;
+        fillColor?: ThemeAwareColor;
+        strokeColor?: ThemeAwareColor;
+        strokeWidth?: number;
+        opacity?: number;
+        fontSize?: number;
+        fontFamily?: string;
+        fontColor?: ThemeAwareColor;
+        scale?: number;
+    }): KritzelShape;
+    /**
+     * Updates the translateX/Y to world coordinates based on screen-space x, y.
+     * This follows the same pattern as KritzelPath.updateDimensions().
+     *
+     * The formula: translateX = (x + initialTranslateX) / scale
+     * where initialTranslateX was -viewportTranslateX
+     *
+     * This converts screen-space position to world coordinates.
+     */
+    updateDimensions(): void;
+    /**
+     * Mounts the shape to a DOM element for rendering.
+     * This method attaches the shape to the provided HTML element, enabling
+     * it to be displayed in the viewport. It performs visibility checks and
+     * prevents redundant mounting operations.
+     *
+     * @param element - The HTML div element to mount the shape to
+     * @returns void
+     */
+    mount(element: HTMLDivElement): void;
+    /**
+     * Mounts the ProseMirror text editor to a DOM element.
+     * This method attaches the rich text editor to the provided container element,
+     * applying font styling and ensuring proper text wrapping. It prevents
+     * redundant DOM operations if the editor is already mounted to the same element.
+     *
+     * @param element - The HTML div element to mount the text editor to
+     * @returns void
+     */
+    mountTextEditor(element: HTMLDivElement): void;
+    /**
+     * Creates and initializes a ProseMirror editor instance for rich text editing.
+     * The editor is configured with a schema that supports basic text formatting
+     * and list nodes. It starts in non-editable mode and handles document changes
+     * by updating the shape's content and syncing with the store.
+     *
+     * @returns A new ProseMirror EditorView instance configured for this shape
+     */
+    private createEditor;
+    /**
+     * Sets the text content of the shape's editor from a serialized document.
+     * This method is typically used to restore content from storage or to apply
+     * remote changes during collaboration. The 'fromRemote' meta flag prevents
+     * the change from being re-broadcast to collaborators.
+     *
+     * @param content - The serialized ProseMirror document content (JSON format)
+     * @returns void
+     */
+    setContent(content: any): void;
+    /**
+     * Resizes the shape to the specified dimensions and position.
+     * This method updates the shape's world-space coordinates and dimensions,
+     * then triggers a store update to persist the changes. Minimum dimension
+     * constraints prevent the shape from becoming invisibly small.
+     *
+     * @param x - New world-space x coordinate for the shape's position
+     * @param y - New world-space y coordinate for the shape's position
+     * @param width - New width of the shape in pixels
+     * @param height - New height of the shape in pixels
+     * @returns void
+     */
+    resize(x: number, y: number, width: number, height: number): void;
+    /**
+     * Focuses the text editor and optionally positions the cursor at specific coordinates.
+     * If coordinates are provided, the cursor is placed at the corresponding text position.
+     * Otherwise, the cursor is placed at the end of the document. On iOS devices,
+     * additional scrolling behavior is triggered to ensure visibility.
+     *
+     * @param coords - Optional screen coordinates to position the cursor
+     * @param coords.x - Screen x coordinate for cursor placement
+     * @param coords.y - Screen y coordinate for cursor placement
+     * @returns void
+     */
+    focus(coords?: {
+        x: number;
+        y: number;
+    }): void;
+    /**
+     * Scrolls the editor into view on iOS devices with a slight delay.
+     * This workaround addresses iOS-specific behavior where the virtual keyboard
+     * can obscure the editor. The delay allows the keyboard to fully appear
+     * before scrolling.
+     *
+     * @returns void
+     */
+    private scrollIntoViewOnIOS;
+    /**
+     * Enters edit mode for the shape, enabling text editing.
+     * This method stores a clone of the current state for potential undo operations,
+     * switches to the shape tool, enables the editor, and focuses at the pointer
+     * location if provided. Keyboard handling is temporarily adjusted to support
+     * text input.
+     *
+     * @param event - Optional pointer event containing the click coordinates for cursor placement
+     * @returns void
+     */
+    edit(event?: PointerEvent): void;
+    /**
+     * Exits edit mode and saves the current text content.
+     * This method serializes the editor's document state, disables editing,
+     * removes focus from the editor, consolidates any temporary changes in the
+     * store, and emits an objects change event to notify listeners.
+     *
+     * @returns void
+     */
+    save(): void;
+    /**
+     * Handles the Escape key while the shape's text editor is in edit mode.
+     * Implements a two-stage behavior: if the editor currently has a non-empty
+     * text selection, the selection is collapsed to a caret without exiting
+     * edit mode. If the selection is already collapsed, edit mode is exited
+     * (saving the current content), the canvas selection is cleared and the
+     * active tool is switched back to the selection tool so subsequent
+     * interactions start fresh.
+     */
+    handleEscape(): void;
+    /**
+     * Handles pointer down events when the shape is in edit mode.
+     * This method stops event propagation for untracked pointers to prevent
+     * the canvas from capturing text selection interactions within the editor.
+     *
+     * @param event - The pointer down event from user interaction
+     * @returns void
+     */
+    handlePointerDown(event: PointerEvent): void;
+    /**
+     * Handles pointer move events when the shape is in edit mode.
+     * This method stops event propagation for untracked pointers to allow
+     * text selection drag operations within the editor without triggering
+     * canvas pan or other interactions.
+     *
+     * @param event - The pointer move event from user interaction
+     * @returns void
+     */
+    handlePointerMove(event: PointerEvent): void;
+    /**
+     * Handles pointer up events when the shape is in edit mode.
+     * This method stops event propagation for untracked pointers to complete
+     * text selection operations within the editor without triggering
+     * canvas click handlers.
+     *
+     * @param event - The pointer up event from user interaction
+     * @returns void
+     */
+    handlePointerUp(event: PointerEvent): void;
+    /**
+     * Creates a copy of this shape with a new editor instance.
+     * This method extends the base copy behavior by creating a fresh
+     * ProseMirror editor for the copied shape and restoring the text
+     * content from the original.
+     *
+     * @returns A new KritzelShape instance with copied properties and content
+     */
+    copy(): KritzelShape;
+    /**
+     * Serializes the shape to a plain JavaScript object for storage or transmission.
+     * This method excludes non-serializable properties like the core reference,
+     * DOM elements, schema, and editor instance. The remaining properties are
+     * deep-cloned to prevent reference issues.
+     *
+     * @returns A serializable object containing all persistent shape properties
+     */
+    serialize(): any;
+    /**
+     * Restores a shape from a serialized object representation.
+     * This method extends the base deserialization by additionally restoring
+     * the text editor content from the serialized data.
+     *
+     * @template KritzelShape - The type parameter for return type consistency
+     * @param object - The serialized shape data to restore from
+     * @returns The deserialized shape instance (this)
+     */
+    deserialize<KritzelShape>(object: any): KritzelShape;
+    /**
+     * Lifecycle hook called after properties are updated via updateObject.
+     * This method automatically adjusts the text color based on fill color
+     * brightness to ensure readability. When the fill color changes, the font
+     * color is recalculated and the editor's styling is updated immediately.
+     *
+     * @param changedProperties - Array of property names that were modified
+     * @returns void
+     */
+    onAfterUpdate(changedProperties: string[]): void;
+    /**
+     * Returns the clipping polygon for arrow intersection calculations.
+     * This method generates a polygon representation of the shape's outline
+     * for use in determining where arrows or connectors should terminate.
+     *
+     * The polygon includes padding for half the stroke width to ensure
+     * arrow heads don't visually overlap the shape's stroke.
+     *
+     * Shape-specific behavior:
+     * - Ellipse: Returns a 32-segment polygon approximation of the ellipse
+     * - Triangle: Returns the 3 corner points, expanded outward by stroke padding
+     * - Rectangle: Returns null to use the default rotatedPolygon from base class
+     *
+     * @returns An array of KritzelPoint objects defining the clipping polygon,
+     *          or null for rectangles (which use the default implementation)
+     */
+    getClipPolygon(): KritzelPoint[] | null;
+    /**
+     * Generates the SVG path string for rendering the shape.
+     * The path uses screen-space coordinates relative to the shape's (x, y) position.
+     * This method supports all shape types and returns the appropriate path commands.
+     *
+     * Path formats by shape type:
+     * - Rectangle: Four-point closed path (M, L, L, L, Z)
+     * - Ellipse: Two-arc closed path using the elliptical arc command (M, A, A)
+     * - Triangle: Three-point closed path with vertices at top-center, bottom-right, bottom-left
+     *
+     * @returns An SVG path data string (d attribute) for the shape
+     */
+    getSvgPath(): string;
+    getSupportedExportFormats(): KritzelObjectExportFormat[];
+    exportAs(format: KritzelObjectExportFormat, context: KritzelObjectExportContext): Promise<string | null>;
+}

package/dist/types/classes/objects/text.class.d.ts

@@ -0,0 +1,197 @@
+import { KritzelBaseObject } from './base-object.class';
+import { KritzelCore } from '../core/core.class';
+import { EditorView } from 'prosemirror-view';
+import { ThemeAwareColor } from '../../constants/color-palette.constants';
+/**
+ * Configuration options for creating a KritzelText instance.
+ */
+export interface KritzelTextConfig {
+    text?: string;
+    translateX?: number;
+    translateY?: number;
+    fontSize?: number;
+    fontFamily?: string;
+    fontColor?: ThemeAwareColor;
+    height?: number;
+    width?: number;
+    scale?: number;
+    rotation?: number;
+    initialWidth?: number;
+    initialHeight?: number;
+    scaleX?: number;
+    scaleY?: number;
+}
+/**
+ * Represents a text object on the canvas that supports rich text editing via ProseMirror.
+ * Extends the base object class to inherit common object properties and behaviors.
+ */
+export declare class KritzelText extends KritzelBaseObject<HTMLDivElement> {
+    __class__: string;
+    fontFamily: string;
+    fontSize: number;
+    fontColor: ThemeAwareColor;
+    initialWidth: number;
+    initialHeight: number;
+    scale: number;
+    scaleFactor: number;
+    isDebugInfoVisible: boolean;
+    isEditable: boolean;
+    isEditing: boolean;
+    isNewlyCreated: boolean;
+    editor: EditorView | null;
+    content: any;
+    private readonly _schema;
+    uneditedObject: KritzelText | null;
+    readonly rows: number;
+    /**
+     * Checks whether the text object contains any content.
+     * @returns `true` if the editor is empty or contains only whitespace, `false` otherwise.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Constructs a new KritzelText instance with optional configuration.
+     * Can be used by consumers to create text objects programmatically:
+     * ```ts
+     * const text = new KritzelText({ text: 'Hello World', translateX: 100, translateY: 100 });
+     * await editor.addObject(text);
+     * ```
+     * @param config - Optional configuration object.
+     * @param config.text - Initial plain text content.
+     * @param config.translateX - Initial X translation position.
+     * @param config.translateY - Initial Y translation position.
+     * @param config.fontSize - Font size in points (default: 8).
+     * @param config.fontFamily - Font family name (default: 'Arial').
+     * @param config.fontColor - Theme-aware color object with light and dark values.
+     * @param config.height - Initial height of the text element.
+     * @param config.width - Initial width of the text element.
+     * @param config.scale - Scale factor for the text object.
+     * @param config.initialWidth - Initial width before scaling.
+     * @param config.initialHeight - Initial height before scaling.
+     * @param config.scaleX - Horizontal scale factor.
+     * @param config.scaleY - Vertical scale factor.
+     */
+    constructor(config?: KritzelTextConfig);
+    /**
+     * Factory method to create a new KritzelText instance with default settings.
+     * Initializes the editor and registers the object with the core store.
+     * @param core - The KritzelCore instance managing the canvas.
+     * @param fontSize - Optional font size in points.
+     * @param fontFamily - Optional font family name.
+     * @param scale - Optional scale factor (defaults to current viewport scale).
+     * @returns A new, fully initialized KritzelText instance.
+     */
+    static create(core: KritzelCore, fontSize?: number, fontFamily?: string, scale?: number, rotation?: number): KritzelText;
+    /**
+     * Mounts the text object to a DOM element, attaching the ProseMirror editor.
+     * Applies font styling and ensures the editor is properly rendered.
+     * @param element - The HTML div element to mount the text object into.
+     */
+    mount(element: HTMLDivElement): void;
+    /**
+     * Creates and configures a new ProseMirror EditorView instance.
+     * Sets up the document schema, plugins, and transaction handling.
+     * @returns A configured ProseMirror EditorView instance.
+     */
+    createEditor(): EditorView;
+    /**
+     * Sets the content of the text editor from a serialized document structure.
+     * Used to restore content from saved state or synchronize with remote changes.
+     * @param content - The serialized ProseMirror document content in JSON format.
+     */
+    setContent(content: any): void;
+    /**
+     * Dynamically adjusts the width and height of the text object based on content.
+     * Recalculates dimensions when content changes and handles rotation offsets
+     * to maintain proper positioning.
+     */
+    adjustSizeOnInput(): void;
+    /**
+     * Resizes the text object while maintaining aspect ratio through scale factor adjustment.
+     * Updates position and dimensions, then persists changes to the store.
+     * @param x - New X position (translateX value).
+     * @param y - New Y position (translateY value).
+     * @param width - Target width for the text object.
+     * @param height - Target height for the text object.
+     */
+    resize(x: number, y: number, width: number, height: number): void;
+    /**
+     * Focuses the text editor and optionally positions the cursor at specific coordinates.
+     * Falls back to placing cursor at the end of the document if coordinates are invalid.
+     * Handles iOS-specific scrolling behavior.
+     * @param coords - Optional coordinates to position the cursor.
+     * @param coords.x - X coordinate for cursor placement.
+     * @param coords.y - Y coordinate for cursor placement.
+     */
+    focus(coords?: {
+        x: number;
+        y: number;
+    }): void;
+    /**
+     * Scrolls the editor into view on iOS devices after a short delay.
+     * Addresses iOS-specific virtual keyboard and viewport issues.
+     */
+    private scrollIntoViewOnIOS;
+    /**
+     * Enters edit mode for the text object, enabling content editing.
+     * Saves a snapshot of the current state, activates the text tool,
+     * enables the editor, and focuses at the pointer position.
+     * @param event - Optional pointer event containing cursor coordinates for focus placement.
+     */
+    edit(event?: PointerEvent): void;
+    /**
+     * Exits edit mode and saves the current content.
+     * Disables the editor, persists content to the document,
+     * consolidates temporary history items, and emits change events.
+     */
+    save(): void;
+    /**
+     * Handles the Escape key while the text object is in edit mode.
+     * Implements a two-stage behavior: if the editor currently has a non-empty
+     * text selection, the selection is collapsed to a caret without exiting
+     * edit mode. If the selection is already collapsed, edit mode is exited
+     * (saving the current content or deleting the object if it is empty) and
+     * the canvas selection is cleared so subsequent tool actions start fresh.
+     */
+    handleEscape(): void;
+    /**
+     * Handles pointer down events during text editing.
+     * Stops event propagation to prevent canvas interaction while editing.
+     * @param event - The pointer down event.
+     */
+    handlePointerDown(event: PointerEvent): void;
+    /**
+     * Handles pointer move events during text editing.
+     * Conditionally stops propagation based on whether the engine is tracking
+     * the pointer, allowing proper event flow during text creation.
+     * @param event - The pointer move event.
+     */
+    handlePointerMove(event: PointerEvent): void;
+    /**
+     * Handles pointer up events during text editing.
+     * Conditionally stops propagation to allow the engine to clean up pointer state,
+     * preventing issues with stale pointers that could cause gesture misinterpretation.
+     * @param event - The pointer up event.
+     */
+    handlePointerUp(event: PointerEvent): void;
+    /**
+     * Creates a deep copy of this text object, including a new editor instance.
+     * Preserves all content from the original object.
+     * @returns A new KritzelText instance with copied properties and content.
+     */
+    copy(): KritzelText;
+    /**
+     * Serializes the text object to a plain object for storage or transmission.
+     * Excludes non-serializable properties like the core reference, editor instance,
+     * and DOM elements.
+     * @returns A plain object containing all serializable properties.
+     */
+    serialize(): any;
+    /**
+     * Restores a text object from a serialized representation.
+     * Reconstructs the editor content from the saved document state.
+     * @template KritzelText - The return type (for type inference).
+     * @param object - The serialized object data to restore from.
+     * @returns The deserialized text object instance.
+     */
+    deserialize<KritzelText>(object: any): KritzelText;
+}

package/dist/types/classes/providers/assets/asset-resolver.class.d.ts

@@ -0,0 +1,141 @@
+import { KritzelAsset } from '../../../interfaces/asset.interface';
+import { KritzelAssetPutMetadata } from '../../../interfaces/asset-provider.interface';
+import { KritzelAssetStorageConfig } from '../../../interfaces/asset-storage-config.interface';
+import { IndexedDBAssetProvider } from './indexeddb-asset-provider.class';
+/**
+ * Thrown when an asset id cannot be located in any configured provider.
+ *
+ * This is distinct from transport / network errors: callers (e.g.
+ * {@link KritzelImage.ensureResolved}) use the type to decide whether a
+ * failure is permanent (asset truly missing) or transient (network blip,
+ * remote temporarily unreachable) and should be retried without
+ * burning the per-page-load attempt budget.
+ */
+export declare class AssetNotFoundError extends Error {
+    readonly assetId: string;
+    constructor(assetId: string, message?: string);
+}
+/**
+ * Orchestrates asset storage across one or more providers.
+ *
+ * Responsibilities:
+ *  - Instantiates providers from a {@link KritzelAssetStorageConfig}.
+ *  - Always ensures an {@link IndexedDBAssetProvider} is present as the
+ *    local cache / optimistic write buffer.
+ *  - Implements a write-through upload pipeline: bytes are written to the
+ *    local provider immediately (so UI renders instantly), and remote
+ *    providers receive a copy via an in-memory retry loop with
+ *    exponential backoff.
+ *  - Resolves asset ids to URLs by walking providers in order; the local
+ *    provider serves as a cache for remote assets.
+ *
+ * Crash / reload resilience: the "needs upload" state is stored directly
+ * on the asset's metadata record in the local IndexedDB provider (as
+ * `KritzelAsset.pendingRemotes`). On `init()` the resolver scans for any
+ * such records and re-enqueues them, so uploads that were interrupted
+ * by a reload eventually complete without requiring a separate queue DB.
+ */
+export declare class KritzelAssetResolver {
+    private _providers;
+    private _local;
+    /** Remote providers ordered as configured. */
+    private _remoteProviders;
+    private _initialized;
+    /**
+     * Promise that resolves when the resolver is ready to serve requests.
+     *
+     * Created lazily so that callers issuing `resolve()` / `fetchBlob()` /
+     * `put()` before {@link init} has been invoked are queued instead of
+     * rejected. This eliminates a race on reload where the renderer
+     * triggers `KritzelImage.ensureResolved()` before the engine has
+     * finished wiring up the asset storage layer.
+     */
+    private _readyPromise;
+    private _resolveReady;
+    private _rejectReady;
+    /** In-memory retry state keyed by `${id}::${providerName}`. */
+    private _pending;
+    private _flushTimer;
+    private _destroyed;
+    private _quiet;
+    /** Dedupes concurrent resolves of the same id. */
+    private _resolvePromises;
+    /** Enables or disables resolver diagnostic logging. */
+    setShowInfo(show: boolean): void;
+    /**
+     * Whether any remote provider is configured. Used by the engine to
+     * decide whether to warn about a missing remote provider when Yjs is
+     * configured for network sync.
+     */
+    get hasRemoteProvider(): boolean;
+    /** Returns the local (IndexedDB) provider instance, if available. */
+    get localProvider(): IndexedDBAssetProvider | null;
+    /**
+     * Initializes the resolver with the given configuration. Idempotent.
+     *
+     * @param config - User-supplied provider list. An `IndexedDBAssetProvider`
+     *                 is automatically prepended when the list contains none,
+     *                 so local caching is always available.
+     */
+    init(config?: KritzelAssetStorageConfig): Promise<void>;
+    /** Tears down the resolver and all providers. */
+    destroy(): void;
+    /**
+     * Uploads a blob through the write-through pipeline.
+     *
+     *   1. The local provider stores the bytes immediately and assigns the id.
+     *   2. Remote providers are marked pending on the local metadata and
+     *      scheduled via the in-memory retry loop.
+     *
+     * Callers receive the asset descriptor synchronously after the local
+     * write completes; remote replication happens in the background.
+     */
+    put(blob: Blob, metadata: KritzelAssetPutMetadata): Promise<KritzelAsset>;
+    /**
+     * Resolves an asset id to a URL usable as `<img src>`. Providers are
+     * tried in order; the first successful response wins.
+     *
+     * Remote hits are cached into the local provider for future offline use.
+     */
+    resolve(id: string): Promise<string>;
+    /**
+     * Returns the raw bytes for an asset. Used for export flows that embed
+     * the bytes inline (e.g. SVG export).
+     */
+    fetchBlob(id: string): Promise<Blob>;
+    /**
+     * Uploads a legacy data-URL and returns the new asset. Used by the
+     * migration step for existing `KritzelImage.src` payloads.
+     */
+    putDataUrl(dataUrl: string, metadata: Omit<KritzelAssetPutMetadata, 'mimeType'> & {
+        mimeType?: string;
+    }): Promise<KritzelAsset>;
+    private logProviderConfiguration;
+    private instantiateProviders;
+    private pendingKey;
+    /**
+     * Reads pending uploads back from the local provider's metadata and
+     * seeds the in-memory retry map. Only uploads targeting remote
+     * providers that are still configured are re-enqueued.
+     */
+    private recoverPendingUploads;
+    private scheduleFlush;
+    private flushQueue;
+    /**
+     * Removes `providerName` from the `pendingRemotes` list on the asset's
+     * metadata record. Clears the field entirely when no providers remain.
+     */
+    private clearPendingRemote;
+    /**
+     * Returns a promise that resolves once {@link init} has completed.
+     *
+     * Callers issuing requests before initialization are queued via this
+     * promise instead of being rejected. If the resolver is destroyed
+     * before init completes, the promise rejects so callers do not hang.
+     */
+    private ensureReady;
+    private getReadyPromise;
+    private generateUuid;
+    private dataUrlToBlob;
+    private canLogInfo;
+}