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

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,27 +15,23 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CANVAS_SIZE_PRESETS: () => CANVAS_SIZE_PRESETS,
   CanvasEditor: () => CanvasEditor,
   CropController: () => CropController,
   DEFAULT_PATTERN_CONFIG: () => DEFAULT_PATTERN_CONFIG,
   EventEmitter: () => EventEmitter,
+  FontRegistry: () => FontRegistry,
   HistoryManager: () => HistoryManager,
   Layer: () => Layer,
   LayerManager: () => LayerManager,
+  LicenseManager: () => LicenseManager,
   PatternManager: () => PatternManager,
+  ProjectManager: () => ProjectManager,
   SnapManager: () => SnapManager,
   UnitConverter: () => UnitConverter,
   applyPatternLocks: () => applyPatternLocks,
@@ -45,15 +39,22 @@ __export(index_exports, {
   captureLocks: () => captureLocks,
   clamp: () => clamp,
   clearPatternImageCache: () => clearPatternImageCache,
+  computeCoverPlacement: () => computeCoverPlacement,
+  computePrintAreaClip: () => computePrintAreaClip,
   computeTilePositions: () => computeTilePositions,
   deserializeEditor: () => deserializeEditor,
   drawTiles: () => drawTiles,
+  escapeXml: () => escapeXml,
   exportDataURL: () => exportDataURL,
+  exportMockup: () => exportMockup,
   exportPNG: () => exportPNG,
   exportSVG: () => exportSVG,
   generateId: () => generateId,
+  isCssColor: () => isCssColor,
+  loadPatternImage: () => loadPatternImage,
   restoreLocks: () => restoreLocks,
   round2: () => round2,
+  sanitizeSvg: () => sanitizeSvg,
   serializeEditor: () => serializeEditor
 });
 module.exports = __toCommonJS(index_exports);
@@ -151,6 +152,10 @@ var LayerManager = class {
   canvas;
   events;
   layers = [];
+  onPropertyChanged;
+  setHistoryCallback(callback) {
+    this.onPropertyChanged = callback;
+  }
   add(type, fabricObject, name, id) {
     const layer = new Layer(type, fabricObject, name, id);
     this.layers.push(layer);
@@ -167,12 +172,39 @@ var LayerManager = class {
     this.layers.splice(index, 1);
     this.events.emit("layer:removed", { layerId: id });
     this.emitChanged();
+    this.onPropertyChanged?.();
+    return true;
+  }
+  /** Replace a layer's render object while preserving its immutable ID and panel state. */
+  replaceObject(id, fabricObject) {
+    const layer = this.get(id);
+    if (!layer || layer.fabricObject === fabricObject) return false;
+    const previous = layer.fabricObject;
+    const stackIndex = this.canvas.getObjects().indexOf(previous);
+    const wasActive = this.canvas.getActiveObject() === previous;
+    this.canvas.remove(previous);
+    layer.fabricObject = fabricObject;
+    fabricObject._layerId = id;
+    fabricObject.set({
+      visible: layer.visible,
+      opacity: layer.opacity,
+      selectable: !layer.locked,
+      evented: !layer.locked
+    });
+    this.canvas.insertAt(Math.max(0, stackIndex), fabricObject);
+    if (wasActive) this.canvas.setActiveObject(fabricObject);
+    this.canvas.requestRenderAll();
+    this.events.emit("layer:modified", { layerId: id });
+    this.emitChanged();
+    this.onPropertyChanged?.();
     return true;
   }
   reorder(id, newIndex) {
     const oldIndex = this.layers.findIndex((l) => l.id === id);
     if (oldIndex === -1) return false;
-    const clamped = Math.max(0, Math.min(this.layers.length - 1, newIndex));
+    if (!Number.isFinite(newIndex)) return false;
+    const clamped = Math.max(0, Math.min(this.layers.length - 1, Math.round(newIndex)));
+    if (oldIndex === clamped) return false;
     const [layer] = this.layers.splice(oldIndex, 1);
     this.layers.splice(clamped, 0, layer);
     this.layers.forEach((l, i) => {
@@ -180,6 +212,7 @@ var LayerManager = class {
     });
     this.events.emit("layer:reordered", { layerIds: this.layers.map((l) => l.id) });
     this.emitChanged();
+    this.onPropertyChanged?.();
     return true;
   }
   select(id) {
@@ -210,33 +243,42 @@ var LayerManager = class {
   setVisibility(id, visible) {
     const layer = this.get(id);
     if (!layer) return;
+    if (layer.visible === visible) return;
     layer.visible = visible;
     layer.fabricObject.visible = visible;
     this.canvas.requestRenderAll();
     this.emitChanged();
+    this.onPropertyChanged?.();
   }
   setLocked(id, locked) {
     const layer = this.get(id);
     if (!layer) return;
+    if (layer.locked === locked) return;
     layer.locked = locked;
     layer.fabricObject.selectable = !locked;
     layer.fabricObject.evented = !locked;
     this.canvas.requestRenderAll();
     this.emitChanged();
+    this.onPropertyChanged?.();
   }
   setOpacity(id, opacity) {
     const layer = this.get(id);
-    if (!layer) return;
-    layer.opacity = opacity;
-    layer.fabricObject.opacity = opacity;
+    if (!layer || !Number.isFinite(opacity)) return;
+    const next = Math.max(0, Math.min(1, opacity));
+    if (layer.opacity === next) return;
+    layer.opacity = next;
+    layer.fabricObject.opacity = next;
     this.canvas.requestRenderAll();
     this.emitChanged();
+    this.onPropertyChanged?.();
   }
   setName(id, name) {
     const layer = this.get(id);
     if (!layer) return;
+    if (layer.name === name) return;
     layer.name = name;
     this.emitChanged();
+    this.onPropertyChanged?.();
   }
   clear() {
     for (const layer of this.layers) {
@@ -260,57 +302,124 @@ var HistoryManager = class {
   undoStack = [];
   redoStack = [];
   maxSize;
+  maxBytes;
   paused = false;
   debounceTimer = null;
   debounceMs;
   getState;
   restoreState;
   events;
+  transactionDepth = 0;
+  transactionDirty = false;
   constructor(opts) {
     this.getState = opts.getState;
     this.restoreState = opts.restoreState;
     this.events = opts.events;
     this.maxSize = opts.maxSize ?? 50;
+    this.maxBytes = opts.maxBytes ?? 50 * 1024 * 1024;
     this.debounceMs = opts.debounceMs ?? 300;
   }
   save() {
     if (this.paused) return;
+    if (this.transactionDepth > 0) {
+      this.transactionDirty = true;
+      return;
+    }
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);
     }
     this.debounceTimer = setTimeout(() => {
       this.saveImmediate();
     }, this.debounceMs);
+    this.emitChanged();
   }
   saveImmediate() {
-    if (this.paused) return;
+    if (this.paused) {
+      this.cancelPending();
+      return;
+    }
+    if (this.transactionDepth > 0) {
+      this.transactionDirty = true;
+      return;
+    }
+    this.cancelPending();
     const state = this.getState();
+    if (this.undoStack.at(-1) === state) {
+      this.emitChanged();
+      return;
+    }
     this.undoStack.push(state);
-    if (this.undoStack.length > this.maxSize) {
+    while (this.undoStack.length > this.maxSize) {
       this.undoStack.shift();
     }
     this.redoStack = [];
+    this.trimToBudget();
+    this.events.emit("history:snapshot", {
+      bytes: state.length * 2,
+      totalBytes: this.snapshotBytes(),
+      entries: this.undoStack.length
+    });
     this.emitChanged();
   }
+  beginTransaction() {
+    if (this.transactionDepth === 0 && this.debounceTimer) this.saveImmediate();
+    this.transactionDepth += 1;
+  }
+  endTransaction() {
+    if (this.transactionDepth === 0) return;
+    this.transactionDepth -= 1;
+    if (this.transactionDepth === 0 && this.transactionDirty) {
+      this.transactionDirty = false;
+      this.saveImmediate();
+    }
+  }
+  async transaction(operation) {
+    this.beginTransaction();
+    try {
+      return await operation();
+    } finally {
+      this.endTransaction();
+    }
+  }
   async undo() {
     this.cancelPending();
-    const state = this.undoStack.pop();
-    if (!state) return;
-    this.redoStack.push(this.getState());
+    const current = this.getState();
+    const committed = this.undoStack.at(-1);
+    if (!committed) return;
+    const currentIsCommitted = current === committed;
+    if (currentIsCommitted && this.undoStack.length < 2) return;
+    const target = currentIsCommitted ? this.undoStack[this.undoStack.length - 2] : committed;
     this.paused = true;
-    await this.restoreState(state);
-    this.paused = false;
-    this.emitChanged();
+    try {
+      await this.restoreState(target);
+      if (currentIsCommitted) this.undoStack.pop();
+      this.redoStack.push(current);
+      this.trimToBudget();
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to undo the last change", error });
+      throw error;
+    } finally {
+      this.paused = false;
+      this.emitChanged();
+    }
   }
   async redo() {
     this.cancelPending();
-    const state = this.redoStack.pop();
+    const state = this.redoStack.at(-1);
     if (!state) return;
-    this.undoStack.push(this.getState());
     this.paused = true;
-    await this.restoreState(state);
-    this.paused = false;
-    this.emitChanged();
+    try {
+      await this.restoreState(state);
+      this.redoStack.pop();
+      if (this.undoStack.at(-1) !== state) this.undoStack.push(state);
+      this.trimToBudget();
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to redo the last change", error });
+      throw error;
+    } finally {
+      this.paused = false;
+      this.emitChanged();
+    }
   }
   /** True while a restore (undo/redo/deserialize) is in flight. Managers that
    * react to canvas events should skip mutating history during this window. */
@@ -324,16 +433,20 @@ var HistoryManager = class {
     this.paused = false;
   }
   canUndo() {
-    return this.undoStack.length > 0;
+    return this.undoStack.length > 1 || this.debounceTimer !== null;
   }
   canRedo() {
     return this.redoStack.length > 0;
   }
   clear() {
+    this.cancelPending();
     this.undoStack = [];
     this.redoStack = [];
     this.emitChanged();
   }
+  getSnapshotBytes() {
+    return this.snapshotBytes();
+  }
   cancelPending() {
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);
@@ -341,9 +454,9 @@ var HistoryManager = class {
     }
   }
   dispose() {
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-    }
+    this.cancelPending();
+    this.transactionDepth = 0;
+    this.transactionDirty = false;
   }
   emitChanged() {
     this.events.emit("history:changed", {
@@ -351,6 +464,20 @@ var HistoryManager = class {
       canRedo: this.canRedo()
     });
   }
+  snapshotBytes() {
+    return [...this.undoStack, ...this.redoStack].reduce(
+      (total, state) => total + state.length * 2,
+      0
+    );
+  }
+  trimToBudget() {
+    while (this.undoStack.length > 1 && this.snapshotBytes() > this.maxBytes) {
+      this.undoStack.shift();
+    }
+    while (this.redoStack.length > 1 && this.snapshotBytes() > this.maxBytes) {
+      this.redoStack.shift();
+    }
+  }
 };
 
 // src/snapping.ts
@@ -570,6 +697,10 @@ var CropController = class {
       top: imgTop + (cropY - (image.cropY ?? 0)) * scaleY
     });
     image.setCoords();
+    if (s.prevAngle) {
+      image.rotate(s.prevAngle);
+      image.setCoords();
+    }
     this.finish();
     this.history.save();
   }
@@ -604,14 +735,18 @@ var STROKE2 = "#22c55e";
 var import_fabric2 = require("fabric");
 var MAX_TILES_PER_AXIS = 200;
 var PatternManager = class {
-  constructor(canvas, layers, history) {
+  constructor(canvas, layers, history, events, sourceResolver) {
     this.canvas = canvas;
     this.layers = layers;
     this.history = history;
+    this.events = events;
+    this.sourceResolver = sourceResolver;
   }
   canvas;
   layers;
   history;
+  events;
+  sourceResolver;
   // Per-layer task chain. apply()/disable() both await an async setSrc on the
   // same fabric image; running two concurrently lets their setSrc resolutions
   // interleave (wrong image installed, original lost). Serialising per layer
@@ -659,6 +794,9 @@ var PatternManager = class {
         throw err;
       }
       this.history.save();
+    }).catch((error) => {
+      this.events.emit("error", { message: "Failed to apply image pattern", error });
+      throw error;
     });
   }
   /**
@@ -714,6 +852,9 @@ var PatternManager = class {
       delete layer.meta.pattern;
       this.canvas.requestRenderAll();
       this.history.save();
+    }).catch((error) => {
+      this.events.emit("error", { message: "Failed to clear image pattern", error });
+      throw error;
     });
   }
   /** Run `task` after any in-flight work for this layer, regardless of outcome. */
@@ -743,7 +884,8 @@ var PatternManager = class {
       cw,
       ch,
       tileW,
-      tileH
+      tileH,
+      this.sourceResolver
     );
     await image.setSrc(dataUrl);
     image.set({
@@ -814,14 +956,23 @@ function elementToDataURL(image) {
 }
 var IMAGE_CACHE_MAX = 16;
 var imageCache = /* @__PURE__ */ new Map();
-function loadImage(src) {
+function loadPatternImage(src, resolver) {
   const cached = imageCache.get(src);
   if (cached) {
     imageCache.delete(src);
     imageCache.set(src, cached);
     return cached;
   }
-  const promise = decodeImage(src);
+  const promise = decodeImage(src).catch(async (originalError) => {
+    if (!resolver) throw originalError;
+    const resolved = await resolver(src);
+    if (!resolved || resolved === src) {
+      throw new Error("Pattern source resolver did not return a usable alternate URL", {
+        cause: originalError
+      });
+    }
+    return decodeImage(resolved);
+  });
   promise.catch(() => {
     if (imageCache.get(src) === promise) imageCache.delete(src);
   });
@@ -844,8 +995,8 @@ function decodeImage(src) {
 function clearPatternImageCache() {
   imageCache.clear();
 }
-async function buildPatternDataURL(src, config, targetW, targetH, baseW, baseH) {
-  const img = await loadImage(src);
+async function buildPatternDataURL(src, config, targetW, targetH, baseW, baseH, sourceResolver) {
+  const img = await loadPatternImage(src, sourceResolver);
   const off = document.createElement("canvas");
   off.width = Math.max(1, Math.round(targetW));
   off.height = Math.max(1, Math.round(targetH));
@@ -905,16 +1056,18 @@ function mod2(n) {
 // src/utils/units.ts
 var MM_PER_INCH = 25.4;
 var UnitConverter = class {
+  unit;
+  dpi;
   constructor(unit = "px", dpi = 72) {
     this.unit = unit;
-    this.dpi = dpi;
+    this.dpi = 72;
+    this.setDpi(dpi);
   }
-  unit;
-  dpi;
   setUnit(unit) {
     this.unit = unit;
   }
   setDpi(dpi) {
+    if (!Number.isFinite(dpi) || dpi <= 0) throw new Error("DPI must be a positive number");
     this.dpi = dpi;
   }
   getUnit() {
@@ -949,38 +1102,72 @@ var UnitConverter = class {
 
 // src/serialization.ts
 var import_fabric3 = require("fabric");
-var VERSION = "1.0.0";
+
+// src/utils/color.ts
+var CSS_COLOR = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\([\d.%+\-\s,/]+\)|[a-z]+)$/i;
+function isCssColor(value, allowEmpty = false) {
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  if (!trimmed) return allowEmpty;
+  return CSS_COLOR.test(trimmed);
+}
+
+// src/serialization.ts
+var VERSION = "2.0.0";
 function serializeEditor(editor) {
   return {
     version: VERSION,
     canvas: {
       width: editor.canvas.getWidth(),
-      height: editor.canvas.getHeight()
+      height: editor.canvas.getHeight(),
+      unit: editor.units.getUnit(),
+      dpi: editor.units.getDpi()
     },
     layers: editor.layers.getAll().map((layer) => layer.serialize()),
     // The configured design background, not the live canvas value (which is
     // forced transparent while a mockup preview is active).
     background: editor.getDesignBackground(),
+    backgroundImage: editor.getDesignBackgroundImage() ? editor.getDesignBackgroundImage().toObject() : null,
     mockup: editor.getMockup()
   };
 }
 async function deserializeEditor(editor, state) {
+  if (!state || !state.canvas || !Array.isArray(state.layers)) {
+    throw new Error("Invalid editor state");
+  }
+  if (!Number.isFinite(state.canvas.width) || !Number.isFinite(state.canvas.height) || state.canvas.width <= 0 || state.canvas.height <= 0 || state.canvas.unit !== void 0 && !["px", "mm", "in"].includes(state.canvas.unit) || state.canvas.dpi !== void 0 && (!Number.isFinite(state.canvas.dpi) || state.canvas.dpi <= 0)) {
+    throw new Error("Invalid editor canvas settings");
+  }
+  const major = Number.parseInt(state.version?.split(".")[0] ?? "1", 10);
+  if (!Number.isFinite(major) || major > 2) {
+    throw new Error(`Unsupported editor state version: ${state.version}`);
+  }
+  if (state.background !== void 0 && !isCssColor(state.background, true)) {
+    throw new Error("Invalid editor background color");
+  }
+  const staged = await Promise.all(
+    state.layers.map(async (serialized) => ({
+      serialized,
+      fabricObject: (await import_fabric3.util.enlivenObjects([serialized.fabricObject]))[0]
+    }))
+  );
+  const stagedBackground = state.backgroundImage ? (await import_fabric3.util.enlivenObjects([state.backgroundImage]))[0] : null;
+  editor.crop.cancel();
   editor.layers.clear();
+  if (state.canvas.unit) editor.units.setUnit(state.canvas.unit);
+  if (state.canvas.dpi !== void 0) editor.units.setDpi(state.canvas.dpi);
   editor.canvas.setDimensions({ width: state.canvas.width, height: state.canvas.height });
-  if (state.background) {
+  if (state.background !== void 0) {
     editor.setBackground(state.background);
   }
-  if (state.mockup !== void 0) {
-    editor.setMockup(state.mockup);
-  }
-  for (const serializedLayer of state.layers) {
-    await restoreLayer(editor, serializedLayer);
+  editor.setBackgroundImageObject(stagedBackground, false);
+  editor.setMockup(state.mockup ?? null);
+  for (const item of staged) {
+    restoreLayer(editor, item.serialized, item.fabricObject);
   }
   editor.canvas.requestRenderAll();
 }
-async function restoreLayer(editor, serialized) {
-  const objects = await import_fabric3.util.enlivenObjects([serialized.fabricObject]);
-  const fabricObject = objects[0];
+function restoreLayer(editor, serialized, fabricObject) {
   const layer = editor.layers.add(serialized.type, fabricObject, serialized.name, serialized.id);
   if (serialized.meta) {
     layer.meta = serialized.meta;
@@ -998,15 +1185,92 @@ async function restoreLayer(editor, serialized) {
 }
 
 // src/export.ts
+function computePrintAreaClip(area, scaleX, scaleY, targetWidth, targetHeight) {
+  const left = Math.max(0, Math.min(targetWidth, area.left * scaleX));
+  const top = Math.max(0, Math.min(targetHeight, area.top * scaleY));
+  const right = Math.max(left, Math.min(targetWidth, (area.left + area.width) * scaleX));
+  const bottom = Math.max(top, Math.min(targetHeight, (area.top + area.height) * scaleY));
+  return { left, top, width: right - left, height: bottom - top };
+}
+function computeCoverPlacement(sourceWidth, sourceHeight, targetWidth, targetHeight) {
+  if (sourceWidth <= 0 || sourceHeight <= 0 || targetWidth <= 0 || targetHeight <= 0) {
+    throw new Error("Cover dimensions must be positive");
+  }
+  const scale = Math.max(targetWidth / sourceWidth, targetHeight / sourceHeight);
+  const width = sourceWidth * scale;
+  const height = sourceHeight * scale;
+  return {
+    left: (targetWidth - width) / 2,
+    top: (targetHeight - height) / 2,
+    width,
+    height
+  };
+}
+function canvasElementToBlob(output, format, quality) {
+  const mime = format === "jpeg" ? "image/jpeg" : `image/${format}`;
+  return new Promise((resolve, reject) => {
+    output.toBlob(
+      (blob) => blob ? resolve(blob) : reject(new Error(`Failed to export ${format}`)),
+      mime,
+      quality
+    );
+  });
+}
 async function exportPNG(canvas, options = {}) {
   const { multiplier = 1, format = "png", quality = 1 } = options;
-  const dataUrl = canvas.toDataURL({
-    format,
-    multiplier,
-    quality
+  const output = canvas.toCanvasElement(multiplier);
+  return canvasElementToBlob(output, format, quality);
+}
+async function exportMockup(canvas, mockup, options = {}) {
+  const { multiplier = 1, format = "png", quality = 1 } = options;
+  const design = canvas.toCanvasElement(multiplier);
+  const output = design.ownerDocument.createElement("canvas");
+  output.width = design.width;
+  output.height = design.height;
+  const context = output.getContext("2d");
+  if (!context) throw new Error("2D canvas context is unavailable");
+  const loadImage = (url) => new Promise((resolve, reject) => {
+    const element = new Image();
+    element.crossOrigin = "anonymous";
+    element.onload = () => resolve(element);
+    element.onerror = () => reject(new Error(`Failed to load mockup image: ${url}`));
+    element.src = url;
   });
-  const response = await fetch(dataUrl);
-  return response.blob();
+  const drawCover = (image) => {
+    const placement = computeCoverPlacement(
+      image.naturalWidth || image.width,
+      image.naturalHeight || image.height,
+      output.width,
+      output.height
+    );
+    context.drawImage(image, placement.left, placement.top, placement.width, placement.height);
+  };
+  drawCover(await loadImage(mockup.image));
+  context.save();
+  if (mockup.printArea && mockup.clipToPrintArea !== false) {
+    const clip = computePrintAreaClip(
+      mockup.printArea,
+      output.width / canvas.getWidth(),
+      output.height / canvas.getHeight(),
+      output.width,
+      output.height
+    );
+    context.beginPath();
+    context.rect(clip.left, clip.top, clip.width, clip.height);
+    context.clip();
+  }
+  context.globalAlpha = Math.max(0, Math.min(1, mockup.designOpacity ?? 1));
+  context.globalCompositeOperation = !mockup.designBlendMode || mockup.designBlendMode === "normal" ? "source-over" : mockup.designBlendMode;
+  context.drawImage(design, 0, 0);
+  context.restore();
+  if (mockup.overlay) {
+    context.save();
+    context.globalAlpha = Math.max(0, Math.min(1, mockup.overlay.opacity ?? 1));
+    context.globalCompositeOperation = mockup.overlay.blendMode === "normal" ? "source-over" : mockup.overlay.blendMode ?? "multiply";
+    drawCover(await loadImage(mockup.overlay.image));
+    context.restore();
+  }
+  return canvasElementToBlob(output, format, quality);
 }
 function exportSVG(canvas) {
   return canvas.toSVG();
@@ -1015,6 +1279,319 @@ function exportDataURL(canvas, format = "png", multiplier = 1) {
   return canvas.toDataURL({ format, multiplier });
 }
 
+// src/utils/svg.ts
+function escapeXml(value) {
+  return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function sanitizeSvg(svg) {
+  const document2 = new DOMParser().parseFromString(svg, "image/svg+xml");
+  if (document2.querySelector("parsererror")) throw new Error("Invalid template SVG");
+  document2.querySelectorAll("script, foreignObject, iframe, object, embed, link, style").forEach((node) => node.remove());
+  document2.querySelectorAll("*").forEach((node) => {
+    for (const attribute of [...node.attributes]) {
+      const name = attribute.name.toLowerCase();
+      const value = attribute.value.trim().toLowerCase();
+      const isLink = name === "href" || name === "xlink:href" || name === "src";
+      const safeLink = value.startsWith("#") || /^data:image\/(?:png|jpeg|webp|gif);base64,/.test(value);
+      if (name.startsWith("on") || isLink && !safeLink || /url\s*\(/.test(value) && !/url\s*\(\s*['"]?#/.test(value) || /(?:javascript:|expression\s*\()/.test(value)) {
+        node.removeAttribute(attribute.name);
+      }
+    }
+  });
+  return new XMLSerializer().serializeToString(document2.documentElement);
+}
+
+// src/fonts.ts
+function fontSource(source) {
+  return /^(?:url|local)\(/.test(source.trim()) ? source : `url(${JSON.stringify(source)})`;
+}
+function mimeForSource(source) {
+  const path = source.split(/[?#]/)[0].toLowerCase();
+  if (path.endsWith(".woff2")) return "font/woff2";
+  if (path.endsWith(".woff")) return "font/woff";
+  if (path.endsWith(".otf")) return "font/otf";
+  return "font/ttf";
+}
+function arrayBufferToBase64(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
+  }
+  return btoa(binary);
+}
+function cssString(value) {
+  return JSON.stringify(value).replace(/[<>&]/g, (char) => `\\${char.charCodeAt(0).toString(16)} `);
+}
+var SAFE_WEIGHT = /^(?:normal|bold|bolder|lighter|[1-9]\d{0,2}(?:\s+[1-9]\d{0,2})?)$/i;
+var SAFE_STYLE = /^(?:normal|italic|oblique(?:\s+-?\d+(?:\.\d+)?deg)?)$/i;
+var SAFE_DISPLAY = /^(?:auto|block|swap|fallback|optional)$/i;
+function cssKeyword(value, pattern, fallback) {
+  const trimmed = value?.trim();
+  return trimmed && pattern.test(trimmed) ? trimmed : fallback;
+}
+function sourceUrl(source) {
+  const trimmed = source.trim();
+  if (trimmed.startsWith("data:")) return trimmed;
+  const match = trimmed.match(/^url\(\s*(['"]?)(.*?)\1\s*\)/i);
+  if (match) return match[2];
+  if (/^local\(/i.test(trimmed)) return null;
+  return trimmed;
+}
+function localName(source) {
+  const match = source.trim().match(/^local\(\s*(['"]?)([^)"'{};]*)\1\s*\)$/i);
+  return match ? match[2].trim() || null : null;
+}
+var FontRegistry = class {
+  definitions = /* @__PURE__ */ new Map();
+  loads = /* @__PURE__ */ new Map();
+  register(definition) {
+    if (!definition.family.trim() || !definition.source.trim()) {
+      throw new Error("Font family and source are required");
+    }
+    this.definitions.set(definition.family, { ...definition });
+    this.loads.delete(definition.family);
+  }
+  unregister(family) {
+    this.loads.delete(family);
+    return this.definitions.delete(family);
+  }
+  getAll() {
+    return [...this.definitions.values()].map((definition) => ({ ...definition }));
+  }
+  load(family) {
+    const cached = this.loads.get(family);
+    if (cached) return cached;
+    const definition = this.definitions.get(family);
+    if (!definition) return Promise.reject(new Error(`Font is not registered: ${family}`));
+    if (typeof FontFace === "undefined" || typeof document === "undefined") {
+      return Promise.reject(new Error("Font loading requires a browser FontFace API"));
+    }
+    const promise = new FontFace(definition.family, fontSource(definition.source), {
+      weight: definition.weight,
+      style: definition.style,
+      display: definition.display
+    }).load().then((font) => {
+      document.fonts.add(font);
+      return font;
+    });
+    promise.catch(() => {
+      if (this.loads.get(family) === promise) this.loads.delete(family);
+    });
+    this.loads.set(family, promise);
+    return promise;
+  }
+  async ready() {
+    if (this.definitions.size === 0) return;
+    await Promise.all([...this.definitions.keys()].map((family) => this.load(family)));
+    await document.fonts.ready;
+  }
+  async getEmbeddedCss() {
+    const rules = await Promise.all(
+      this.getAll().map(async (definition) => {
+        const url = sourceUrl(definition.source);
+        let cssSource;
+        if (url && !url.startsWith("data:")) {
+          const response = await fetch(url);
+          if (!response.ok) throw new Error(`Failed to fetch font: ${url}`);
+          const data = arrayBufferToBase64(await response.arrayBuffer());
+          const mime = response.headers.get("content-type") || mimeForSource(url);
+          cssSource = `url(${cssString(`data:${mime};base64,${data}`)})`;
+        } else if (url) {
+          cssSource = `url(${cssString(url)})`;
+        } else {
+          const name = localName(definition.source);
+          if (!name) {
+            throw new Error(`Unsupported font source for embedding: ${definition.family}`);
+          }
+          cssSource = `local(${cssString(name)})`;
+        }
+        const weight = cssKeyword(definition.weight, SAFE_WEIGHT, "normal");
+        const style = cssKeyword(definition.style, SAFE_STYLE, "normal");
+        const display = cssKeyword(definition.display, SAFE_DISPLAY, "swap");
+        return `@font-face{font-family:${cssString(definition.family)};src:${cssSource};font-weight:${weight};font-style:${style};font-display:${display}}`;
+      })
+    );
+    return rules.join("\n");
+  }
+};
+
+// src/licensing.ts
+function domainMatches(hostname, pattern) {
+  const host = hostname.toLowerCase();
+  const expected = pattern.toLowerCase();
+  if (expected.startsWith("*.")) {
+    const suffix = expected.slice(1);
+    return host.endsWith(suffix) && host.length > suffix.length;
+  }
+  return host === expected;
+}
+function isLocal(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost");
+}
+var LicenseManager = class {
+  constructor(config = {}) {
+    this.config = config;
+    const hostname = config.hostname ?? globalThis.location?.hostname ?? "localhost";
+    const environment = config.environment ?? "development";
+    if (environment !== "production" || isLocal(hostname)) {
+      this.status = { state: "exempt", payload: null };
+      this.readyPromise = Promise.resolve(this.status);
+    } else if (!config.key) {
+      this.status = { state: "community", payload: null };
+      this.readyPromise = Promise.resolve(this.status);
+    } else {
+      this.status = { state: "checking", payload: null };
+      this.readyPromise = this.validate(config.key, hostname);
+    }
+  }
+  config;
+  status;
+  readyPromise;
+  getStatus() {
+    return this.status;
+  }
+  ready() {
+    return this.readyPromise;
+  }
+  hasFeature(feature) {
+    return this.status.state === "valid" && (this.status.payload.features ?? []).includes(feature);
+  }
+  track(name) {
+    this.config.onUsage?.({
+      name,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      licenseId: this.status.state === "valid" ? this.status.payload.id : void 0
+    });
+  }
+  async validate(key, hostname) {
+    const payload = await this.config.verifyOffline?.(key) ?? null;
+    if (!payload) return this.status = { state: "invalid", payload: null };
+    if (payload.expiresAt && Date.parse(payload.expiresAt) < Date.now()) {
+      return this.status = { state: "expired", payload };
+    }
+    if (!payload.domains.some((domain) => domainMatches(hostname, domain))) {
+      return this.status = { state: "domain-mismatch", payload };
+    }
+    return this.status = { state: "valid", payload };
+  }
+};
+
+// src/project.ts
+var ProjectManager = class {
+  constructor(editor) {
+    this.editor = editor;
+    const first = { id: generateId(), name: "Page 1", state: editor.toJSON() };
+    this.pages = [first];
+    this.activePageId = first.id;
+  }
+  editor;
+  pages;
+  activePageId;
+  getAll() {
+    return this.pages.map(({ id, name }) => ({ id, name }));
+  }
+  getActivePageId() {
+    return this.activePageId;
+  }
+  add(name = `Page ${this.pages.length + 1}`, cloneCurrent = false) {
+    this.saveCurrent();
+    const source = structuredClone(this.editor.toJSON());
+    const state = cloneCurrent ? source : this.blankState(source);
+    const page = { id: generateId(), name, state };
+    this.pages.push(page);
+    this.emitChanged();
+    return page.id;
+  }
+  async switchTo(id) {
+    if (id === this.activePageId) return true;
+    const page = this.pages.find((candidate) => candidate.id === id);
+    if (!page) return false;
+    this.saveCurrent();
+    await this.editor.fromJSON(structuredClone(page.state));
+    this.activePageId = id;
+    this.emitChanged();
+    return true;
+  }
+  async duplicate(id) {
+    this.saveCurrent();
+    const source = this.pages.find((page2) => page2.id === id);
+    if (!source) return null;
+    const page = {
+      id: generateId(),
+      name: `${source.name} copy`,
+      state: structuredClone(source.state)
+    };
+    const index = this.pages.indexOf(source);
+    this.pages.splice(index + 1, 0, page);
+    this.emitChanged();
+    return page.id;
+  }
+  async remove(id) {
+    if (this.pages.length === 1) return false;
+    const index = this.pages.findIndex((page) => page.id === id);
+    if (index < 0) return false;
+    if (id === this.activePageId) {
+      const next = this.pages[index + 1] ?? this.pages[index - 1];
+      await this.editor.fromJSON(structuredClone(next.state));
+      this.activePageId = next.id;
+    }
+    this.pages.splice(index, 1);
+    this.emitChanged();
+    return true;
+  }
+  rename(id, name) {
+    const page = this.pages.find((candidate) => candidate.id === id);
+    const trimmed = name.trim();
+    if (!page || !trimmed || page.name === trimmed) return false;
+    page.name = trimmed;
+    this.emitChanged();
+    return true;
+  }
+  reorder(id, newIndex) {
+    const index = this.pages.findIndex((page2) => page2.id === id);
+    if (index < 0 || !Number.isFinite(newIndex)) return false;
+    const target = Math.max(0, Math.min(this.pages.length - 1, Math.round(newIndex)));
+    if (target === index) return false;
+    const [page] = this.pages.splice(index, 1);
+    this.pages.splice(target, 0, page);
+    this.emitChanged();
+    return true;
+  }
+  toJSON() {
+    this.saveCurrent();
+    return {
+      version: "1.0.0",
+      activePageId: this.activePageId,
+      pages: structuredClone(this.pages)
+    };
+  }
+  async fromJSON(project) {
+    if (project?.version !== "1.0.0" || !Array.isArray(project.pages) || project.pages.length === 0 || !project.pages.some((page) => page.id === project.activePageId)) {
+      throw new Error("Invalid project state");
+    }
+    const pages = structuredClone(project.pages);
+    const active = pages.find((page) => page.id === project.activePageId);
+    await this.editor.fromJSON(structuredClone(active.state));
+    this.pages = pages;
+    this.activePageId = active.id;
+    this.emitChanged();
+  }
+  saveCurrent() {
+    const page = this.pages.find((candidate) => candidate.id === this.activePageId);
+    if (page) page.state = structuredClone(this.editor.toJSON());
+  }
+  blankState(source) {
+    return { ...source, layers: [], mockup: null };
+  }
+  emitChanged() {
+    this.editor.events.emit("project:changed", {
+      activePageId: this.activePageId,
+      pages: this.getAll()
+    });
+  }
+};
+
 // src/editor.ts
 var MIN_ZOOM = 0.1;
 var MAX_ZOOM = 8;
@@ -1027,6 +1604,9 @@ var CanvasEditor = class {
   snapping;
   crop;
   patterns;
+  fonts;
+  licensing;
+  pages;
   fileAdapter;
   imageProvider;
   zoomLevel = 1;
@@ -1035,8 +1615,12 @@ var CanvasEditor = class {
   // transparent while a mockup preview is shown, so this is the source of truth
   // for serialization and export — not the (possibly transient) canvas value.
   designBackground;
+  designBackgroundImage = null;
   constructor(canvasElement, config) {
     this.events = new EventEmitter();
+    this.fonts = new FontRegistry();
+    config.fonts?.forEach((font) => this.fonts.register(font));
+    this.licensing = new LicenseManager(config.license);
     this.units = new UnitConverter(config.unit ?? "px", config.dpi ?? 72);
     const widthPx = this.units.toPixels(config.width);
     const heightPx = this.units.toPixels(config.height);
@@ -1059,18 +1643,73 @@ var CanvasEditor = class {
       },
       events: this.events
     });
+    this.layers.setHistoryCallback(() => this.history.save());
     this.snapping = new SnapManager(this.canvas, this.events);
     this.crop = new CropController(this.canvas, this.history, this.events);
-    this.patterns = new PatternManager(this.canvas, this.layers, this.history);
+    this.patterns = new PatternManager(
+      this.canvas,
+      this.layers,
+      this.history,
+      this.events,
+      config.patternSourceResolver
+    );
     this.setupCanvasEvents();
     this.history.saveImmediate();
+    this.pages = new ProjectManager(this);
   }
   // ─── Layer Operations ────────────────────────────────
   async addImage(url, options) {
-    const img = await import_fabric4.FabricImage.fromURL(url, {}, { originX: "left", originY: "top", ...options });
-    const layer = this.layers.add("image", img);
-    this.history.save();
-    return layer;
+    try {
+      const img = await import_fabric4.FabricImage.fromURL(
+        url,
+        {},
+        { originX: "left", originY: "top", ...options }
+      );
+      const layer = this.layers.add("image", img);
+      this.history.save();
+      return layer;
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to add image", error });
+      throw error;
+    }
+  }
+  /** Replace an image source without changing its layer identity or visual transform. */
+  async replaceImageSource(layerId, url) {
+    const layer = this.layers.get(layerId);
+    if (!layer || layer.type !== "image") throw new Error(`Image layer not found: ${layerId}`);
+    if (layer.meta.pattern) {
+      throw new Error("Clear the pattern before replacing the image source");
+    }
+    if (this.crop.activeLayerId() === layerId) this.crop.cancel();
+    const previous = layer.fabricObject;
+    try {
+      const replacement = await import_fabric4.FabricImage.fromURL(url, {}, { originX: "left", originY: "top" });
+      replacement.set({
+        left: previous.left,
+        top: previous.top,
+        originX: previous.originX,
+        originY: previous.originY,
+        width: previous.width,
+        height: previous.height,
+        cropX: previous.cropX,
+        cropY: previous.cropY,
+        scaleX: previous.scaleX,
+        scaleY: previous.scaleY,
+        angle: previous.angle,
+        skewX: previous.skewX,
+        skewY: previous.skewY,
+        flipX: previous.flipX,
+        flipY: previous.flipY
+      });
+      replacement.filters = [...previous.filters];
+      replacement.applyFilters();
+      replacement.setCoords();
+      this.layers.replaceObject(layerId, replacement);
+      return layer;
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to replace image source", error });
+      throw error;
+    }
   }
   addText(text, options) {
     const textbox = new import_fabric4.Textbox(text, {
@@ -1093,27 +1732,42 @@ var CanvasEditor = class {
     this.history.save();
     return layer;
   }
-  async addTemplate(template, _params) {
-    const { Textbox: TextboxClass } = await import("fabric");
-    const placeholder = new TextboxClass(`[Template: ${template.name}]`, {
-      fontSize: 24,
-      fontFamily: "Arial",
-      fill: "#666666",
-      width: 300,
-      originX: "left",
-      originY: "top"
-    });
-    const layer = this.layers.add(
-      "template",
-      placeholder,
-      template.name
+  async addTemplate(template, params) {
+    const values = {};
+    for (const parameter of template.parameters) {
+      const value = params[parameter.key] ?? parameter.default;
+      if (value === void 0) throw new Error(`Missing template parameter: ${parameter.key}`);
+      if (parameter.type === "number" && !Number.isFinite(Number(value))) {
+        throw new Error(`Invalid number for template parameter: ${parameter.key}`);
+      }
+      if (parameter.type === "color" && !isCssColor(value)) {
+        throw new Error(`Invalid color for template parameter: ${parameter.key}`);
+      }
+      values[parameter.key] = value;
+    }
+    const resolved = sanitizeSvg(
+      template.svg.replace(/\{\{(\w+)(?:[|:]([^}]*))?\}\}/g, (token, key, fallback) => {
+        const value = values[key] ?? fallback;
+        return value === void 0 ? token : escapeXml(value);
+      })
     );
+    const { objects, options } = await (0, import_fabric4.loadSVGFromString)(resolved);
+    const validObjects = objects.filter((object) => object !== null);
+    if (validObjects.length === 0) throw new Error("Template SVG contains no renderable objects");
+    const group = import_fabric4.util.groupSVGElements(validObjects, options);
+    group.set({
+      left: this.canvas.getWidth() / 2,
+      top: this.canvas.getHeight() / 2,
+      originX: "center",
+      originY: "center"
+    });
+    const layer = this.layers.add("template", group, template.name);
     this.history.save();
     return layer;
   }
   removeLayer(id) {
-    this.layers.remove(id);
-    this.history.save();
+    if (this.crop.activeLayerId() === id) this.crop.cancel();
+    if (this.layers.remove(id)) this.history.save();
   }
   selectLayer(id) {
     this.layers.select(id);
@@ -1148,35 +1802,173 @@ var CanvasEditor = class {
     clone.setCoords();
     const copy = this.layers.add(layer.type, clone, `${layer.name} copy`);
     copy.meta = structuredClone(layer.meta);
+    copy.visible = layer.visible;
+    copy.locked = layer.locked;
+    copy.opacity = layer.opacity;
+    clone.set({
+      visible: layer.visible,
+      selectable: !layer.locked,
+      evented: !layer.locked,
+      opacity: layer.opacity
+    });
     this.canvas.setActiveObject(clone);
     this.canvas.requestRenderAll();
     this.history.save();
     return copy;
   }
+  applyImageAdjustments(layerId, adjustments) {
+    const layer = this.layers.get(layerId);
+    if (!layer || layer.type !== "image") return false;
+    const image = layer.fabricObject;
+    const previous = layer.meta.imageAdjustments ?? {};
+    const next = { ...previous, ...adjustments };
+    const clampAdjustment = (value, min = -1) => clamp(value ?? 0, min, 1);
+    image.filters = [
+      new import_fabric4.filters.Brightness({ brightness: clampAdjustment(next.brightness) }),
+      new import_fabric4.filters.Contrast({ contrast: clampAdjustment(next.contrast) }),
+      new import_fabric4.filters.Saturation({ saturation: clampAdjustment(next.saturation) }),
+      new import_fabric4.filters.Blur({ blur: clampAdjustment(next.blur, 0) })
+    ];
+    layer.meta.imageAdjustments = next;
+    image.applyFilters();
+    this.canvas.requestRenderAll();
+    this.history.save();
+    return true;
+  }
+  /** Combine two or more layers into a single editable group layer. */
+  async groupLayers(ids, name = "Group") {
+    const uniqueIds = [...new Set(ids)];
+    const children = uniqueIds.map((id) => this.layers.get(id)).filter((layer) => layer !== void 0);
+    if (children.length < 2 || children.length !== uniqueIds.length) return null;
+    return this.history.transaction(() => {
+      const childData = children.map((layer) => structuredClone(layer.toData()));
+      const objects = children.map((layer) => layer.fabricObject);
+      for (const layer of children) this.layers.remove(layer.id);
+      const group = new import_fabric4.Group(objects);
+      const grouped = this.layers.add("group", group, name);
+      grouped.meta.groupChildren = childData;
+      this.layers.select(grouped.id);
+      this.history.save();
+      return grouped;
+    });
+  }
+  /** Restore a group created by groupLayers back to its original layer records. */
+  async ungroupLayer(id) {
+    const grouped = this.layers.get(id);
+    const childData = grouped?.meta.groupChildren;
+    if (!grouped || grouped.type !== "group" || !Array.isArray(childData)) return [];
+    const group = grouped.fabricObject;
+    return this.history.transaction(() => {
+      const transform = group.calcTransformMatrix();
+      const objects = group.removeAll();
+      this.layers.remove(id);
+      const restored = objects.map((object, index) => {
+        import_fabric4.util.addTransformToObject(object, transform);
+        object.setCoords();
+        const data = childData[index];
+        const layer = this.layers.add(data?.type ?? "group", object, data?.name, data?.id);
+        if (data?.meta) layer.meta = structuredClone(data.meta);
+        if (data && !data.visible) this.layers.setVisibility(layer.id, false);
+        if (data?.locked) this.layers.setLocked(layer.id, true);
+        if (data && data.opacity !== 1) this.layers.setOpacity(layer.id, data.opacity);
+        return layer;
+      });
+      this.history.save();
+      this.layers.select(restored[0]?.id ?? null);
+      return restored;
+    });
+  }
   // ─── Serialization ──────────────────────────────────
   toJSON() {
     return serializeEditor(this);
   }
   async fromJSON(state) {
-    await deserializeEditor(this, state);
-    this.patterns.repinAll();
+    const managedByHistory = this.history.isRestoring();
+    if (!managedByHistory) {
+      this.history.saveImmediate();
+      this.history.pause();
+    }
+    try {
+      await deserializeEditor(this, state);
+      this.patterns.repinAll();
+    } catch (error) {
+      if (!managedByHistory) {
+        this.events.emit("error", { message: "Failed to load editor state", error });
+      }
+      throw error;
+    } finally {
+      if (!managedByHistory) this.history.resume();
+    }
+    if (!managedByHistory) {
+      this.history.clear();
+      this.history.saveImmediate();
+    }
   }
   // ─── Export ──────────────────────────────────────────
   async toPNG(options) {
-    this.events.emit("export:start", { format: "png" });
-    const blob = await this.withDesignBackground(() => exportPNG(this.canvas, options));
-    this.events.emit("export:complete", { format: "png" });
-    return blob;
+    return this.toRaster(options?.format ?? "png", options);
+  }
+  async toJPEG(options) {
+    return this.toRaster("jpeg", options);
+  }
+  async toWebP(options) {
+    return this.toRaster("webp", options);
+  }
+  async toRaster(format, options) {
+    this.events.emit("export:start", { format });
+    try {
+      await this.fonts.ready();
+      const blob = await this.withDesignBackground(
+        () => exportPNG(this.canvas, { ...options, format })
+      );
+      this.events.emit("export:complete", { format });
+      this.licensing.track(`export:${format}`);
+      return blob;
+    } catch (error) {
+      this.events.emit("error", { message: `Failed to export ${format.toUpperCase()}`, error });
+      throw error;
+    }
   }
   toSVG() {
     this.events.emit("export:start", { format: "svg" });
-    const svg = this.withDesignBackground(() => exportSVG(this.canvas));
-    this.events.emit("export:complete", { format: "svg" });
-    return svg;
+    try {
+      const svg = this.withDesignBackground(() => exportSVG(this.canvas));
+      this.events.emit("export:complete", { format: "svg" });
+      this.licensing.track("export:svg");
+      return svg;
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to export SVG", error });
+      throw error;
+    }
+  }
+  async toSVGAsync(options = {}) {
+    await this.fonts.ready();
+    const svg = this.toSVG();
+    if (options.embedFonts === false || this.fonts.getAll().length === 0) return svg;
+    try {
+      const css = await this.fonts.getEmbeddedCss();
+      return svg.replace(/(<svg\b[^>]*>)/i, `$1<defs><style>${css}</style></defs>`);
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to embed fonts in SVG", error });
+      throw error;
+    }
   }
   toDataURL(format = "png", multiplier = 1) {
     return this.withDesignBackground(() => exportDataURL(this.canvas, format, multiplier));
   }
+  /** Export the current product-preview composite. Advanced warping is host-defined. */
+  async toMockupImage(options = {}) {
+    if (!this.mockup) throw new Error("No mockup is configured");
+    await this.fonts.ready();
+    try {
+      const blob = await exportMockup(this.canvas, this.mockup, options);
+      this.licensing.track(`export:mockup:${options.format ?? "png"}`);
+      return blob;
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to export mockup", error });
+      throw error;
+    }
+  }
   /**
    * Run an export with the configured design background applied, even when a
    * mockup preview has forced the live canvas transparent — so exports reflect
@@ -1185,11 +1977,14 @@ var CanvasEditor = class {
   withDesignBackground(fn) {
     if (!this.mockup) return fn();
     const previewBg = this.canvas.backgroundColor;
+    const previewImage = this.canvas.backgroundImage;
     this.canvas.backgroundColor = this.designBackground;
+    this.canvas.backgroundImage = this.designBackgroundImage ?? void 0;
     try {
       return fn();
     } finally {
       this.canvas.backgroundColor = previewBg;
+      this.canvas.backgroundImage = previewImage;
     }
   }
   toPrintifyPositioning() {
@@ -1204,7 +1999,8 @@ var CanvasEditor = class {
     for (const layer of imageLayers) {
       const obj = layer.fabricObject;
       const center = obj.getCenterPoint();
-      result[layer.name] = {
+      const key = result[layer.name] ? `${layer.name}-${layer.id}` : layer.name;
+      result[key] = {
         x: round2(center.x / canvasW),
         y: round2(center.y / canvasH),
         scale: round2(obj.scaleX ?? 1),
@@ -1213,26 +2009,92 @@ var CanvasEditor = class {
     }
     return result;
   }
+  /** Provider-neutral, ID-stable placement data in 0..1 canvas coordinates. */
+  toNormalizedPositioning() {
+    const canvasWidth = this.canvas.getWidth();
+    const canvasHeight = this.canvas.getHeight();
+    return this.layers.getAll().map((layer) => {
+      const object = layer.fabricObject;
+      const center = object.getCenterPoint();
+      const bounds = object.getBoundingRect();
+      return {
+        layerId: layer.id,
+        name: layer.name,
+        type: layer.type,
+        centerX: round2(center.x / canvasWidth),
+        centerY: round2(center.y / canvasHeight),
+        width: round2(bounds.width / canvasWidth),
+        height: round2(bounds.height / canvasHeight),
+        scaleX: round2(object.scaleX ?? 1),
+        scaleY: round2(object.scaleY ?? 1),
+        angle: round2(object.angle ?? 0)
+      };
+    });
+  }
+  toProviderPositioning(adapter) {
+    return adapter.map(this.toNormalizedPositioning(), {
+      width: this.canvas.getWidth(),
+      height: this.canvas.getHeight()
+    });
+  }
   // ─── File Operations ────────────────────────────────
   async save(filename, format) {
     if (!this.fileAdapter) return void 0;
     let data;
     if (format === "png") {
       data = await this.toPNG();
+    } else if (format === "jpeg") {
+      data = await this.toJPEG();
+    } else if (format === "webp") {
+      data = await this.toWebP();
     } else if (format === "svg") {
-      data = this.toSVG();
+      data = await this.toSVGAsync();
     } else {
       data = JSON.stringify(this.toJSON(), null, 2);
     }
-    return this.fileAdapter.save(data, filename, format);
+    try {
+      return await this.fileAdapter.save(data, filename, format);
+    } catch (error) {
+      this.events.emit("error", { message: `Failed to save ${format}`, error });
+      throw error;
+    }
   }
   async uploadImage(file) {
-    if (!this.imageProvider) return void 0;
-    return this.imageProvider.upload(file);
+    if (!this.imageProvider?.upload) return void 0;
+    try {
+      return await this.imageProvider.upload(file);
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to upload image", error });
+      throw error;
+    }
   }
   async browseImages() {
     if (!this.imageProvider?.browse) return null;
-    return this.imageProvider.browse();
+    try {
+      return await this.imageProvider.browse();
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to browse images", error });
+      throw error;
+    }
+  }
+  async searchImages(query, options) {
+    if (!this.imageProvider?.search) return null;
+    try {
+      return await this.imageProvider.search(query, options);
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to search images", error });
+      throw error;
+    }
+  }
+  /** Track provider usage, then insert its hotlinked image as a normal layer. */
+  async addProviderImage(image, options) {
+    try {
+      await this.imageProvider?.trackUse?.(image);
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to record image use", error });
+      throw error;
+    }
+    return this.addImage(image.url, options);
   }
   setFileAdapter(adapter) {
     this.fileAdapter = adapter;
@@ -1248,15 +2110,130 @@ var CanvasEditor = class {
       this.canvas.requestRenderAll();
     }
     this.history.save();
+    this.events.emit("canvas:modified", {});
   }
   getDesignBackground() {
     return this.designBackground;
   }
-  resize(width, height) {
+  getDesignBackgroundImage() {
+    return this.designBackgroundImage;
+  }
+  async setBackgroundImage(url, options = {}) {
+    if (url === null) {
+      this.setBackgroundImageObject(null);
+      return;
+    }
+    try {
+      const image = await import_fabric4.FabricImage.fromURL(url, {}, { originX: "left", originY: "top" });
+      const width = image.width || 1;
+      const height = image.height || 1;
+      const canvasWidth = this.canvas.getWidth();
+      const canvasHeight = this.canvas.getHeight();
+      const fit = options.fit ?? "cover";
+      const sx = canvasWidth / width;
+      const sy = canvasHeight / height;
+      const scaleX = fit === "stretch" ? sx : fit === "contain" ? Math.min(sx, sy) : Math.max(sx, sy);
+      const scaleY = fit === "stretch" ? sy : scaleX;
+      image.set({
+        left: (canvasWidth - width * scaleX) / 2,
+        top: (canvasHeight - height * scaleY) / 2,
+        scaleX,
+        scaleY,
+        opacity: clamp(options.opacity ?? 1, 0, 1),
+        selectable: false,
+        evented: false
+      });
+      this.setBackgroundImageObject(image);
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to set background image", error });
+      throw error;
+    }
+  }
+  /** Used by state restoration and advanced integrations with an existing Fabric object. */
+  setBackgroundImageObject(image, save = true) {
+    this.designBackgroundImage = image;
+    this.canvas.backgroundImage = this.mockup ? void 0 : image ?? void 0;
+    this.canvas.requestRenderAll();
+    if (save) this.history.save();
+    this.events.emit("canvas:modified", {});
+  }
+  setTransparentBackground() {
+    this.setBackground("");
+  }
+  resize(width, height, options = {}) {
     const widthPx = this.units.toPixels(width);
     const heightPx = this.units.toPixels(height);
+    const oldWidth = this.canvas.getWidth();
+    const oldHeight = this.canvas.getHeight();
+    const scaleContent = options.scaleContent ?? true;
+    if (scaleContent && oldWidth > 0 && oldHeight > 0) {
+      const sx = widthPx / oldWidth;
+      const sy = heightPx / oldHeight;
+      for (const layer of this.layers.getAll()) {
+        if (layer.meta.pattern) continue;
+        const object = layer.fabricObject;
+        object.set({
+          left: (object.left ?? 0) * sx,
+          top: (object.top ?? 0) * sy,
+          scaleX: (object.scaleX ?? 1) * sx,
+          scaleY: (object.scaleY ?? 1) * sy
+        });
+        object.setCoords();
+      }
+      if (this.designBackgroundImage) {
+        this.designBackgroundImage.set({
+          left: (this.designBackgroundImage.left ?? 0) * sx,
+          top: (this.designBackgroundImage.top ?? 0) * sy,
+          scaleX: (this.designBackgroundImage.scaleX ?? 1) * sx,
+          scaleY: (this.designBackgroundImage.scaleY ?? 1) * sy
+        });
+        this.designBackgroundImage.setCoords();
+      }
+    }
     this.canvas.setDimensions({ width: widthPx, height: heightPx });
+    this.patterns.repinAll();
     this.canvas.requestRenderAll();
+    this.history.save();
+    this.events.emit("canvas:modified", {});
+  }
+  /** Effective source resolution for an image at its current physical size. */
+  getImageDpi(layerId) {
+    const layer = this.layers.get(layerId);
+    if (!layer || layer.type !== "image") return null;
+    const image = layer.fabricObject;
+    const sourcePixels = image.width ?? 0;
+    const displayedPixels = image.getScaledWidth();
+    if (sourcePixels <= 0 || displayedPixels <= 0) return null;
+    return round2(sourcePixels / (displayedPixels / this.units.getDpi()));
+  }
+  validateImageDpi(minimumDpi = 300) {
+    return this.layers.getAll().filter((layer) => layer.type === "image" && !layer.meta.pattern).flatMap((layer) => {
+      const effectiveDpi = this.getImageDpi(layer.id);
+      return effectiveDpi !== null && effectiveDpi < minimumDpi ? [{ layerId: layer.id, layerName: layer.name, effectiveDpi, minimumDpi }] : [];
+    });
+  }
+  /** Render a small data-URL preview without changing document dimensions. */
+  toThumbnail(maxWidth = 320, maxHeight = 320, format = "png") {
+    const multiplier = Math.min(
+      1,
+      maxWidth / this.canvas.getWidth(),
+      maxHeight / this.canvas.getHeight()
+    );
+    return this.toDataURL(format, multiplier);
+  }
+  bringToFront(id) {
+    return this.layers.reorder(id, this.layers.count() - 1);
+  }
+  sendToBack(id) {
+    return this.layers.reorder(id, 0);
+  }
+  bringForward(id) {
+    const index = this.layers.getAll().findIndex((layer) => layer.id === id);
+    return index >= 0 && this.layers.reorder(id, index + 1);
+  }
+  sendBackward(id) {
+    const index = this.layers.getAll().findIndex((layer) => layer.id === id);
+    return index >= 0 && this.layers.reorder(id, index - 1);
   }
   // ─── Zoom ───────────────────────────────────────────
   //
@@ -1294,6 +2271,20 @@ var CanvasEditor = class {
     const sy = (viewportHeight - padding * 2) / h;
     this.setZoom(Math.min(sx, sy));
   }
+  /** Zoom until the current selection fills the artboard viewport. */
+  zoomToSelection(padding = 24) {
+    const active = this.canvas.getActiveObject();
+    if (!active) return;
+    active.setCoords();
+    const bounds = active.getBoundingRect();
+    if (bounds.width <= 0 || bounds.height <= 0) return;
+    this.setZoom(
+      Math.min(
+        (this.canvas.getWidth() - padding * 2) / bounds.width,
+        (this.canvas.getHeight() - padding * 2) / bounds.height
+      )
+    );
+  }
   // ─── Patterns ───────────────────────────────────────
   applyPattern(layerId, config) {
     return this.patterns.apply(layerId, config);
@@ -1305,8 +2296,10 @@ var CanvasEditor = class {
   setMockup(mockup) {
     this.mockup = mockup;
     this.canvas.backgroundColor = mockup ? "" : this.designBackground;
+    this.canvas.backgroundImage = mockup ? void 0 : this.designBackgroundImage ?? void 0;
     this.canvas.requestRenderAll();
     this.events.emit("mockup:changed", { mockup });
+    this.history.save();
   }
   clearMockup() {
     this.setMockup(null);
@@ -1319,6 +2312,7 @@ var CanvasEditor = class {
     this.snapping.dispose();
     this.crop.dispose();
     this.history.dispose();
+    clearPatternImageCache();
     this.events.removeAllListeners();
     this.canvas.dispose();
   }
@@ -1359,16 +2353,30 @@ var DEFAULT_PATTERN_CONFIG = {
   rotationStepH: 0,
   rotationStepV: 0
 };
+
+// src/presets.ts
+var CANVAS_SIZE_PRESETS = [
+  { id: "a4-portrait", name: "A4 portrait", width: 210, height: 297, unit: "mm", dpi: 300 },
+  { id: "a4-landscape", name: "A4 landscape", width: 297, height: 210, unit: "mm", dpi: 300 },
+  { id: "us-letter", name: "US Letter", width: 8.5, height: 11, unit: "in", dpi: 300 },
+  { id: "shirt-front", name: "Garment front", width: 12, height: 16, unit: "in", dpi: 300 },
+  { id: "instagram-square", name: "Social square", width: 1080, height: 1080, unit: "px", dpi: 72 },
+  { id: "story", name: "Story", width: 1080, height: 1920, unit: "px", dpi: 72 }
+];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CANVAS_SIZE_PRESETS,
   CanvasEditor,
   CropController,
   DEFAULT_PATTERN_CONFIG,
   EventEmitter,
+  FontRegistry,
   HistoryManager,
   Layer,
   LayerManager,
+  LicenseManager,
   PatternManager,
+  ProjectManager,
   SnapManager,
   UnitConverter,
   applyPatternLocks,
@@ -1376,15 +2384,22 @@ var DEFAULT_PATTERN_CONFIG = {
   captureLocks,
   clamp,
   clearPatternImageCache,
+  computeCoverPlacement,
+  computePrintAreaClip,
   computeTilePositions,
   deserializeEditor,
   drawTiles,
+  escapeXml,
   exportDataURL,
+  exportMockup,
   exportPNG,
   exportSVG,
   generateId,
+  isCssColor,
+  loadPatternImage,
   restoreLocks,
   round2,
+  sanitizeSvg,
   serializeEditor
 });
 //# sourceMappingURL=index.js.map