@kritzel/engine 0.4.31

package/dist/types/helpers/svg-export.helper.d.ts

@@ -0,0 +1,231 @@
+import { KritzelBaseObject } from '../classes/objects/base-object.class';
+import { ThemeName } from '../interfaces/theme.interface';
+import { KritzelBoundingBox } from '../interfaces/bounding-box.interface';
+/**
+ * Options for SVG export.
+ */
+export interface SvgExportOptions {
+    /** Theme to use for resolving theme-aware colors. Defaults to current theme. */
+    theme?: ThemeName;
+    /** Padding around the exported content in world units. Defaults to 0. */
+    padding?: number;
+    /** Whether to include XML declaration. Defaults to true. */
+    includeXmlDeclaration?: boolean;
+    /**
+     * Enables raster-safe serialization for objects that normally rely on
+     * `<foreignObject>` (currently text). Use this when the generated SVG is
+     * rendered into an `<img>` and then drawn to a canvas for PNG export.
+     */
+    rasterSafeForCanvas?: boolean;
+    /**
+     * Map of image object id -> inlined `data:` URL used to embed image
+     * bytes directly into the exported markup. Required for the bytes to
+     * survive rasterization (e.g. SVG -> PNG), because browsers refuse to
+     * load external/`blob:` resources referenced from an SVG loaded into
+     * an `<img>` element. Populate via {@link KritzelSvgExportHelper.resolveImageDataUrls}.
+     */
+    imageDataUrls?: Map<string, string>;
+}
+/**
+ * Minimal structural contract for the asset resolver dependency used by
+ * the export inlining path. Declared structurally to keep this helper
+ * decoupled from the concrete resolver implementation.
+ */
+export interface SvgExportAssetResolver {
+    fetchBlob(id: string): Promise<Blob>;
+}
+/**
+ * Helper class for exporting Kritzel objects to SVG format.
+ * Generates clean, standards-compliant SVG markup from canvas objects.
+ */
+export declare class KritzelSvgExportHelper {
+    /**
+     * Calculates the combined bounding box that encompasses all objects.
+     * Uses rotatedBoundingBox to account for object rotation.
+     * @param objects - Array of objects to calculate bounds for
+     * @returns Combined bounding box, or null if no objects provided
+     */
+    static calculateCombinedBounds(objects: KritzelBaseObject[]): KritzelBoundingBox | null;
+    /**
+     * Generates a complete SVG document string from the given objects.
+     * @param objects - Objects to export
+     * @param options - Export options
+     * @returns SVG document string
+     */
+    static generateSvg(objects: KritzelBaseObject[], options?: SvgExportOptions): string;
+    /**
+     * Flattens a list of objects, expanding groups into their children recursively.
+     * @param objects - Objects to flatten
+     * @returns Flat array of all objects including group children
+     */
+    private static flattenObjects;
+    /**
+     * Resolves every image referenced by the given objects (including those
+     * nested inside groups) to an inlined `data:` URL, keyed by object id.
+     *
+     * This is required for export flows that rasterize the SVG (e.g. PNG
+     * export): an SVG loaded into an `<img>` element will NOT load external
+     * or `blob:` resources, so a `<image href="blob:...">` renders as a
+     * broken-image placeholder. Embedding the bytes as a base64 `data:` URL
+     * makes the image self-contained and survive rasterization.
+     *
+     * Resolution is best-effort: images that fail to resolve are simply
+     * omitted from the map, and the SVG falls back to whatever `href` the
+     * synchronous path would have produced.
+     * @param objects - Objects to inline images for
+     * @param assetResolver - Resolver used to fetch asset bytes; optional
+     * @returns Map of image object id -> inlined `data:` URL
+     */
+    static resolveImageDataUrls(objects: KritzelBaseObject[], assetResolver?: SvgExportAssetResolver): Promise<Map<string, string>>;
+    /**
+     * Reads a Blob into a base64 `data:` URL.
+     * @param blob - The blob to encode
+     * @returns Promise resolving to the data URL string
+     */
+    private static blobToDataUrl;
+    /**
+     * Encodes a byte array to base64 across browser and Node-like runtimes.
+     */
+    private static uint8ToBase64;
+    /**
+     * Collects SVG defs (markers, patterns, etc.) needed by the objects.
+     * @param objects - Objects to collect defs for
+     * @param theme - Theme for color resolution
+     * @returns Array of def element strings
+     */
+    private static collectDefs;
+    /**
+     * Generates an SVG marker element for line arrows.
+     * @param line - The line object
+     * @param end - Which end of the line ('start' or 'end')
+     * @param theme - Theme for color resolution
+     * @returns SVG marker element string
+     */
+    private static generateArrowMarker;
+    /**
+     * Converts a Kritzel object to its SVG element representation.
+     * @param object - The object to convert
+     * @param theme - Theme for color resolution
+     * @param imageDataUrls - Optional map of image id -> inlined data URL
+     * @returns SVG element string, or empty string if object type is not supported
+     */
+    static objectToSvgElement(object: KritzelBaseObject, theme?: ThemeName, imageDataUrls?: Map<string, string>, rasterSafeForCanvas?: boolean): string;
+    /**
+     * Converts a KritzelPath to SVG.
+     * @param path - The path object
+     * @param theme - Theme for color resolution
+     * @returns SVG element string
+     */
+    private static pathToSvg;
+    /**
+     * Converts a KritzelLine to SVG.
+     * @param line - The line object
+     * @param theme - Theme for color resolution
+     * @returns SVG element string
+     */
+    private static lineToSvg;
+    /**
+     * Converts a KritzelShape to SVG.
+     * @param shape - The shape object
+     * @param theme - Theme for color resolution
+     * @returns SVG element string
+     */
+    private static shapeToSvg;
+    /**
+     * Converts a KritzelText to SVG using foreignObject for rich text support.
+     * @param text - The text object
+     * @param theme - Theme for color resolution
+     * @returns SVG element string
+     */
+    private static textToSvg;
+    /**
+     * Converts a KritzelText to SVG using pure SVG text primitives.
+     * This path avoids `<foreignObject>`, which taints canvases when the
+     * generated SVG is rasterized through `<img>` and `drawImage`.
+     */
+    private static textToSvgRasterSafe;
+    /**
+     * Converts a KritzelImage to SVG.
+     *
+     * Prefers an inlined `data:` URL from `imageDataUrls` (keyed by object
+     * id) when provided, so the embedded bytes survive rasterization to
+     * PNG. Falls back to `resolvedSrc` (populated by the renderer via the
+     * asset resolver) and finally the legacy inline `src` field for
+     * documents persisted before the asset layer existed.
+     *
+     * Note: a `blob:` `resolvedSrc` renders correctly on-canvas but becomes
+     * a broken-image placeholder once the SVG is loaded into an `<img>` and
+     * drawn to a canvas. Callers that rasterize the SVG must pass
+     * `imageDataUrls` (see {@link KritzelSvgExportHelper.resolveImageDataUrls}).
+     * @param image - The image object
+     * @param imageDataUrls - Optional map of image id -> inlined data URL
+     * @returns SVG element string
+     */
+    private static imageToSvg;
+    /**
+     * Converts a KritzelDynamicObject to SVG.
+     * SVG mode: embeds HTML in foreignObject (best-effort).
+     * PNG/raster mode: renders placeholder rect with warning.
+     * @param obj - The dynamic object
+     * @param rasterSafeForCanvas - If true, render placeholder (for PNG export)
+     * @returns SVG element string
+     */
+    private static dynamicObjectToSvg;
+    /**
+     * Converts a KritzelGroup to SVG by recursively converting children.
+     * @param group - The group object
+     * @param theme - Theme for color resolution
+     * @param imageDataUrls - Optional map of image id -> inlined data URL
+     * @returns SVG element string
+     */
+    private static groupToSvg;
+    /**
+     * Builds a transform attribute string for an object.
+     * Combines translation and rotation.
+     * @param object - The object to build transform for
+     * @returns Transform attribute value string
+     */
+    private static buildTransform;
+    /**
+     * Returns a safe non-zero scale for export geometry calculations.
+     */
+    private static getObjectScale;
+    /**
+     * Converts ProseMirror JSON content to HTML string.
+     * @param content - ProseMirror document JSON
+     * @param context - The text or shape object for styling context
+     * @param theme - Theme for color resolution
+     * @returns HTML string
+     */
+    private static prosemirrorToHtml;
+    /**
+     * Converts a ProseMirror node to HTML.
+     * @param node - ProseMirror node JSON
+     * @param theme - Theme for color resolution
+     * @returns HTML string
+     */
+    private static nodeToHtml;
+    /**
+     * Converts ProseMirror JSON content to plain-text lines.
+     * Used by raster-safe SVG export, which cannot depend on HTML/foreignObject.
+     */
+    private static prosemirrorToPlainTextLines;
+    /**
+     * Converts a ProseMirror node tree into plain text.
+     */
+    private static nodeToPlainText;
+    /**
+     * Applies a ProseMirror mark to text.
+     * @param text - The text to wrap
+     * @param mark - The mark to apply
+     * @param theme - Theme for color resolution
+     * @returns Wrapped HTML string
+     */
+    private static applyMark;
+    /**
+     * Escapes HTML special characters.
+     * @param str - String to escape
+     * @returns Escaped string
+     */
+    private static escapeHtml;
+}

package/dist/types/helpers/theme.helper.d.ts

@@ -0,0 +1,42 @@
+import { KritzelTheme } from '../interfaces/theme.interface';
+export declare class ThemeHelper {
+    private static readonly appliedVariableNames;
+    /**
+     * Converts a camelCase string to kebab-case.
+     * @example ThemeHelper.camelToKebab('controlHoverBackgroundColor') → 'control-hover-background-color'
+     * @example ThemeHelper.camelToKebab('backgroundColor') → 'background-color'
+     * @example ThemeHelper.camelToKebab('gap') → 'gap'
+     */
+    static camelToKebab(str: string): string;
+    /**
+     * Recursively flattens a theme object into a map of CSS variable names to values.
+     * Skips the 'name' property at the root level since it's the theme identifier, not a CSS value.
+     *
+     * @param theme - The theme object to flatten
+     * @param prefix - The CSS variable prefix (default: '--kritzel')
+     * @returns A Map of CSS variable names to their values
+     *
+     * @example
+     * ThemeHelper.flattenThemeToVariables(lightTheme)
+     * // Returns Map {
+     * //   '--kritzel-global-pointer-cursor' => 'pointer',
+    * //   '--kritzel-toolbar-gap' => '8px',
+     * //   ...
+     * // }
+     */
+    static flattenThemeToVariables(theme: KritzelTheme, prefix?: string): Map<string, string>;
+    /**
+     * Applies a map of CSS variables to an HTML element.
+     *
+     * @param element - The target HTML element
+     * @param variables - A Map of CSS variable names to values
+     */
+    static applyVariablesToElement(element: HTMLElement, variables: Map<string, string>): void;
+    /**
+     * Convenience method that flattens a theme and applies it to an element in one call.
+     *
+     * @param element - The target HTML element
+     * @param theme - The theme object to apply
+     */
+    static applyThemeToElement(element: HTMLElement, theme: KritzelTheme): void;
+}

package/dist/types/helpers/tool-config.helper.d.ts

@@ -0,0 +1,4 @@
+import { ConfigurableTool, ToolConfigDefinition } from '../interfaces/tool-config.interface';
+export declare class KritzelToolConfigHelper {
+    static getToolConfig(tool: ConfigurableTool): ToolConfigDefinition | null;
+}

package/dist/types/helpers/wheel.helper.d.ts

@@ -0,0 +1,9 @@
+import { KritzelDynamicObject } from '../classes/objects/dynamic-object.class';
+export declare class KritzelWheelHelper {
+    static shouldKeepWheelInDynamicObject(ev: WheelEvent, dynamicObject: KritzelDynamicObject): boolean;
+    private static getScrollableContainerFromEventPath;
+    private static isScrollableElement;
+    private static canElementConsumeWheel;
+    private static canElementConsumeVerticalWheel;
+    private static canElementConsumeHorizontalWheel;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,109 @@
+/**
+ * @fileoverview entry point for your component library
+ *
+ * This is the entry point for your component library. Use this file to export utilities,
+ * constants or data structure that accompany your components.
+ *
+ * DO NOT use this file to export your components. Instead, use the recommended approaches
+ * to consume components of this package as outlined in the `README.md`.
+ */
+export type * from './components';
+export type HTMLKritzelEngineElement = HTMLElementTagNameMap['kritzel-engine'];
+export * from './classes/objects/base-object.class';
+export * from './classes/objects/text.class';
+export * from './classes/objects/path.class';
+export * from './classes/objects/image.class';
+export * from './classes/objects/line.class';
+export * from './classes/objects/group.class';
+export * from './classes/objects/shape.class';
+export * from './classes/objects/dynamic-object.class';
+export * from './classes/objects/selection-group.class';
+export * from './classes/objects/selection-box.class';
+export * from './classes/tools/base-tool.class';
+export * from './classes/tools/brush-tool.class';
+export * from './classes/tools/line-tool.class';
+export * from './classes/tools/eraser-tool.class';
+export * from './classes/tools/image-tool.class';
+export * from './classes/tools/text-tool.class';
+export * from './classes/tools/shape-tool.class';
+export * from './helpers/cursor.helper';
+export * from './helpers/keyboard.helper';
+export * from './helpers/devices.helper';
+export * from './helpers/theme.helper';
+export * from './helpers/object.helper';
+export * from './helpers/color.helper';
+export * from './helpers/html.helper';
+export * from './helpers/tool-config.helper';
+export * from './classes/tools/selection-tool.class';
+export * from './classes/providers/sync/broadcast-sync-provider.class';
+export * from './classes/providers/sync/in-memory-sync-provider.class';
+export * from './classes/providers/sync/indexeddb-sync-provider.class';
+export * from './classes/providers/sync/websocket-sync-provider.class';
+export * from './classes/providers/sync/hocuspocus-sync-provider.class';
+export * from './classes/providers/assets/asset-resolver.class';
+export * from './classes/providers/assets/indexeddb-asset-provider.class';
+export * from './classes/providers/assets/http-asset-provider.class';
+export * from './classes/providers/assets/presigned-asset-provider.class';
+export * from './classes/core/workspace.class';
+export * from './classes/managers/anchor.manager';
+export * from './classes/managers/theme.manager';
+export * from './classes/managers/localization.manager';
+export * from './classes/managers/license.manager';
+export * from './classes/registries/dynamic-object-renderer.registry';
+export * from './classes/registries/font-registry.class';
+export * from './classes/registries/icon-registry.class';
+export * from './interfaces/toolbar-item.interface';
+export * from './interfaces/menu-item.interface';
+export * from './interfaces/object-export.interface';
+export * from './interfaces/object-change-event.interface';
+export * from './interfaces/dynamic-object-renderer.interface';
+export * from './interfaces/sync-provider.interface';
+export * from './interfaces/sync-config.interface';
+export * from './interfaces/asset.interface';
+export * from './interfaces/asset-provider.interface';
+export * from './interfaces/asset-storage-config.interface';
+export * from './interfaces/login-config.interface';
+export * from './interfaces/document-metadata.interface';
+export * from './interfaces/anchor.interface';
+export * from './interfaces/viewport-state.interface';
+export * from './interfaces/context-menu-state.interface';
+export * from './interfaces/user.interface';
+export * from './interfaces/theme.interface';
+export * from './interfaces/localization.interface';
+export * from './interfaces/shortcut.interface';
+export * from './interfaces/share.interface';
+export * from './interfaces/engine-state.interface';
+export * from './interfaces/debug-info.interface';
+export * from './interfaces/bounding-box.interface';
+export * from './interfaces/polygon.interface';
+export * from './interfaces/font.interface';
+export * from './interfaces/settings.interface';
+export * from './interfaces/dialog.interface';
+export * from './interfaces/master-detail.interface';
+export * from './interfaces/tool-config.interface';
+export * from './interfaces/arrow-head.interface';
+export * from './events/active-workspace-change.event';
+export * from './events/editor-is-ready.event';
+export * from './events/login.event';
+export * from './configs/default-brush-tool.config';
+export * from './configs/default-text-tool.config';
+export * from './configs/default-line-tool.config';
+export * from './configs/default-shape-tool.config';
+export * from './configs/default-asset-storage.config';
+export * from './configs/default-sync.config';
+export * from './themes/light-theme';
+export * from './themes/dark-theme';
+export * from './locales/en-locale';
+export * from './locales/de-locale';
+export * from './locales/fr-locale';
+export * from './enums/alignment.enum';
+export * from './enums/shape-type.enum';
+export * from './interfaces/migration.interface';
+export * from './helpers/migration.helper';
+export * from './migrations/app-state.migrations';
+export * from './migrations/workspace.migrations';
+export * from './constants/schema.constants';
+export * from './constants/color-palette.constants';
+export * from './constants/text-tool-fonts.constants';
+export * from './constants/engine.constants';
+export * from './constants/version';

package/dist/types/interfaces/anchor.interface.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Represents an anchor connection from a line endpoint to another object's center.
+ */
+export interface LineAnchor {
+    /** The ID of the object that this line endpoint is anchored to */
+    objectId: string;
+}
+/**
+ * Entry in the anchor index that tracks which lines are anchored to an object.
+ */
+export interface AnchorIndexEntry {
+    /** The ID of the line that has an anchor */
+    lineId: string;
+    /** Which endpoint of the line is anchored */
+    endpoint: 'start' | 'end';
+}
+/**
+ * Represents a potential snap target during line endpoint dragging.
+ */
+export interface SnapTarget {
+    /** The ID of the object that can be snapped to */
+    objectId: string;
+    /** The center X coordinate of the snap target in world coordinates */
+    centerX: number;
+    /** The center Y coordinate of the snap target in world coordinates */
+    centerY: number;
+}
+/**
+ * Shared visualization payload for snap preview and active snap states.
+ */
+export interface SnapIndicatorCandidate {
+    /** The ID of the object being snapped to */
+    objectId: string;
+    /** Which endpoint of the line is being snapped */
+    endpoint: 'start' | 'end';
+    /** The center X coordinate for the snap indicator */
+    centerX: number;
+    /** The center Y coordinate for the snap indicator */
+    centerY: number;
+    /** The X coordinate of the line endpoint (world coords) */
+    lineEndpointX: number;
+    /** The Y coordinate of the line endpoint (world coords) */
+    lineEndpointY: number;
+    /** The X coordinate where the line intersects the object's edge (world coords) */
+    edgeX?: number;
+    /** The Y coordinate where the line intersects the object's edge (world coords) */
+    edgeY?: number;
+    /** The stroke color of the line being snapped */
+    lineStroke?: string;
+    /** The stroke width of the line being snapped */
+    lineStrokeWidth?: number;
+    /** Arrow offset to apply to the edge point (in world coords) */
+    arrowOffset?: number;
+    /** Arrow style for the snapping endpoint */
+    arrowStyle?: 'triangle' | 'open' | 'diamond' | 'circle';
+    /** Arrow fill color */
+    arrowFill?: string;
+    /** The X coordinate of the control point (world coords), if any */
+    controlX?: number;
+    /** The Y coordinate of the control point (world coords), if any */
+    controlY?: number;
+    /** The t parameter on the curve where the edge intersection occurs (0-1) */
+    t?: number;
+}
+/**
+ * Represents the current snap candidate state during dragging.
+ */
+export interface SnapCandidate extends SnapIndicatorCandidate {
+}
+/**
+ * Represents a preview candidate shown before active snapping is engaged.
+ */
+export interface SnapPreviewCandidate extends SnapIndicatorCandidate {
+}
+/**
+ * Visualization data for rendering anchor indicator lines.
+ */
+export interface AnchorVisualization {
+    /** The X coordinate where the line intersects the object's edge */
+    edgeX: number;
+    /** The Y coordinate where the line intersects the object's edge */
+    edgeY: number;
+    /** The center X coordinate of the anchored object */
+    centerX: number;
+    /** The center Y coordinate of the anchored object */
+    centerY: number;
+    /** Optional SVG path describing the curved dashed segment */
+    pathD?: string;
+}
+/**
+ * Render data for anchor lines visualization (dashed lines from edge to center).
+ */
+export interface AnchorLinesRenderData {
+    /** The stroke width of the line */
+    lineStrokeWidth: number;
+    /** The stroke width for the indicator circle */
+    indicatorStrokeWidth: string;
+    /** The dash array for the dashed line */
+    dashArray: string;
+    /** The radius of the indicator circle */
+    indicatorRadius: number;
+    /** Visualization data for the start anchor, if any */
+    startAnchorViz: AnchorVisualization | null;
+    /** Visualization data for the end anchor, if any */
+    endAnchorViz: AnchorVisualization | null;
+}
+/**
+ * Render data for snap indicator visualization.
+ */
+export interface SnapIndicatorRenderData {
+    /** The radius of the indicator circle */
+    indicatorRadius: number;
+    /** The stroke width for the indicator circle */
+    indicatorStrokeWidth: string;
+    /** The stroke width for the line */
+    lineStrokeWidth: string;
+    /** The dash array for the dashed line */
+    dashArray: string;
+    /** The stroke color of the line */
+    lineStroke: string;
+    /** The center X coordinate */
+    centerX: number;
+    /** The center Y coordinate */
+    centerY: number;
+    /** The X coordinate of the line endpoint */
+    lineEndpointX: number;
+    /** The Y coordinate of the line endpoint */
+    lineEndpointY: number;
+    /** The X coordinate where the line intersects the object's edge */
+    edgeX?: number;
+    /** The Y coordinate where the line intersects the object's edge */
+    edgeY?: number;
+    /** Arrow offset to apply to the edge point */
+    arrowOffset?: number;
+    /** Arrow style for the snapping endpoint */
+    arrowStyle?: 'triangle' | 'open' | 'diamond' | 'circle';
+    /** Arrow fill color */
+    arrowFill?: string;
+    /** The X coordinate for the end of the solid line part (accounting for arrow offset) */
+    solidLineEndX?: number;
+    /** The Y coordinate for the end of the solid line part (accounting for arrow offset) */
+    solidLineEndY?: number;
+    /** SVG points string for the arrow head at the edge */
+    arrowPoints?: string;
+    /** SVG path d string for the dashed line part (if curved) */
+    snapLinePath?: string;
+}

package/dist/types/interfaces/arrow-head.interface.d.ts

@@ -0,0 +1,27 @@
+import { ThemeAwareColor } from '../constants/color-palette.constants';
+/**
+ * Arrow head style types
+ */
+export type ArrowHeadStyle = 'triangle' | 'open' | 'diamond' | 'circle';
+/**
+ * Configuration for a single arrow head
+ */
+export interface ArrowHeadConfig {
+    /** Whether to display the arrow head */
+    enabled: boolean;
+    /** Arrow head style (defaults to 'triangle') */
+    style?: ArrowHeadStyle;
+    /** Size of the arrow head in pixels (defaults to strokeWidth * 3) */
+    size?: number;
+    /** Fill color (defaults to stroke color of the line) */
+    fill?: ThemeAwareColor;
+}
+/**
+ * Configuration for arrow heads at both ends of a line
+ */
+export interface LineArrowConfig {
+    /** Arrow head at the start of the line */
+    start?: ArrowHeadConfig;
+    /** Arrow head at the end of the line */
+    end?: ArrowHeadConfig;
+}

package/dist/types/interfaces/asset-provider.interface.d.ts

@@ -0,0 +1,88 @@
+import { KritzelAsset } from './asset.interface';
+/**
+ * Distinguishes local-only asset providers (IndexedDB) from network providers
+ * (HTTP, presigned S3, etc.) that replicate assets across devices.
+ */
+export type AssetProviderType = 'local' | 'remote';
+/**
+ * Metadata supplied when uploading a new asset. The provider is free to
+ * use or ignore hints (e.g. width/height) but MUST persist `mimeType`.
+ */
+export interface KritzelAssetPutMetadata {
+    mimeType: string;
+    width?: number;
+    height?: number;
+    durationMs?: number;
+    originalFilename?: string;
+    kind?: KritzelAsset['kind'];
+    /**
+     * Optional pre-assigned asset id. When provided, the provider should
+     * use this id instead of generating one. This allows the resolver to
+     * coordinate ids across a write-through (local + remote) pipeline.
+     */
+    id?: string;
+}
+/**
+ * Contract every asset storage provider implements.
+ *
+ * Providers are pluggable and may be combined in a chain (see AssetResolver).
+ * Local providers (e.g. IndexedDB) are always-on and serve as a cache and
+ * offline buffer. Remote providers replicate assets across devices so the
+ * Yjs CRDT can stay small (it only stores the asset id, not the bytes).
+ */
+export interface IAssetStorageProvider {
+    /** Whether this provider stores bytes locally or over the network. */
+    readonly type: AssetProviderType;
+    /** Human-readable provider name used in logs / diagnostics. */
+    readonly name: string;
+    /**
+     * Initializes the provider. Called once by the resolver before first use.
+     * Local providers typically open an IDB connection here; remote providers
+     * may perform a health check or no-op.
+     */
+    init(): Promise<void>;
+    /**
+     * Destroys the provider and releases any held resources.
+     */
+    destroy(): void;
+    /**
+     * Returns true if this provider is capable of resolving the given asset id.
+     * Remote providers usually return true unconditionally (they don't know
+     * without a round-trip); local providers may return true only when the
+     * asset is actually cached.
+     */
+    canResolve(id: string): boolean | Promise<boolean>;
+    /**
+     * Persists the given bytes and returns the resulting asset descriptor.
+     * If `metadata.id` is provided, the provider MUST use that id.
+     */
+    put(blob: Blob, metadata: KritzelAssetPutMetadata): Promise<KritzelAsset>;
+    /**
+     * Returns a URL usable directly as an `<img src>` / `<video src>`.
+     * Local providers typically return a `blob:` URL; remote providers return
+     * an HTTPS URL (possibly signed).
+     */
+    resolve(id: string): Promise<string>;
+    /**
+     * Returns the raw bytes for the given asset. Used for export flows that
+     * need to embed the bytes (e.g. SVG export with inline images).
+     */
+    fetch(id: string): Promise<Blob>;
+    /**
+     * Optional deletion support. Providers without deletion (e.g. immutable
+     * CDNs) may omit this.
+     */
+    delete?(id: string): Promise<void>;
+}
+/**
+ * Factory function type for creating asset provider instances.
+ * Mirrors the shape used by sync providers for consistency.
+ */
+export interface AssetProviderFactory {
+    create(): IAssetStorageProvider;
+}
+/**
+ * Configuration value accepted by `KritzelAssetStorageConfig.providers`:
+ * either a zero-arg class constructor or a factory object.
+ */
+export type AssetProviderConfig = (new () => IAssetStorageProvider) | AssetProviderFactory;