@shotstack/shotstack-canvas 1.1.0 → 1.1.1

package/dist/entry.node.cjs

@@ -30,7 +30,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/env/entry.node.ts
 var entry_node_exports = {};
 __export(entry_node_exports, {
-  createTextEngine: () => createTextEngine
+  createTextEngine: () => createTextEngine,
+  isGlyphFill: () => isGlyphFill2,
+  isShadowFill: () => isShadowFill2
 });
 module.exports = __toCommonJS(entry_node_exports);
 
@@ -164,19 +166,28 @@ var RichTextAssetSchema = import_joi.default.object({
 var hbSingleton = null;
 async function initHB(wasmBaseURL) {
   if (hbSingleton) return hbSingleton;
-  const harfbuzzjs = await import("harfbuzzjs");
-  const hbPromise = harfbuzzjs.default;
-  if (typeof hbPromise === "function") {
-    hbSingleton = await hbPromise();
-  } else if (hbPromise && typeof hbPromise.then === "function") {
-    hbSingleton = await hbPromise;
-  } else {
-    hbSingleton = hbPromise;
-  }
-  if (!hbSingleton || typeof hbSingleton.createBuffer !== "function") {
-    throw new Error("Failed to initialize HarfBuzz: invalid API");
+  try {
+    const mod = await import("harfbuzzjs");
+    const candidate = mod.default;
+    let hb;
+    if (typeof candidate === "function") {
+      hb = await candidate();
+    } else if (candidate && typeof candidate.then === "function") {
+      hb = await candidate;
+    } else {
+      hb = candidate;
+    }
+    if (!hb || typeof hb.createBuffer !== "function" || typeof hb.createFont !== "function") {
+      throw new Error("Failed to initialize HarfBuzz: unexpected export shape from 'harfbuzzjs'.");
+    }
+    void wasmBaseURL;
+    hbSingleton = hb;
+    return hbSingleton;
+  } catch (err) {
+    throw new Error(
+      `Failed to initialize HarfBuzz: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
-  return hbSingleton;
 }
 
 // src/core/font-registry.ts
@@ -199,7 +210,13 @@ var FontRegistry = class {
       return;
     }
     this.initPromise = this._doInit();
-    await this.initPromise;
+    try {
+      await this.initPromise;
+    } catch (err) {
+      throw new Error(
+        `Failed to initialize FontRegistry: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
   }
   async _doInit() {
     try {
@@ -211,7 +228,13 @@ var FontRegistry = class {
   }
   async getHB() {
     if (!this.hb) {
-      await this.init();
+      try {
+        await this.init();
+      } catch (err) {
+        throw new Error(
+          `Failed to get HarfBuzz instance: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
     }
     return this.hb;
   }
@@ -219,48 +242,111 @@ var FontRegistry = class {
     return `${desc.family}__${desc.weight ?? "400"}__${desc.style ?? "normal"}`;
   }
   async registerFromBytes(bytes, desc) {
-    if (!this.hb) await this.init();
-    const k = this.key(desc);
-    if (this.fonts.has(k)) return;
-    const blob = this.hb.createBlob(bytes);
-    const face = this.hb.createFace(blob, 0);
-    const font = this.hb.createFont(face);
-    const upem = face.upem || 1e3;
-    font.setScale(upem, upem);
-    this.blobs.set(k, blob);
-    this.faces.set(k, face);
-    this.fonts.set(k, font);
+    try {
+      if (!this.hb) await this.init();
+      const k = this.key(desc);
+      if (this.fonts.has(k)) return;
+      const blob = this.hb.createBlob(bytes);
+      const face = this.hb.createFace(blob, 0);
+      const font = this.hb.createFont(face);
+      const upem = face.upem || 1e3;
+      font.setScale(upem, upem);
+      this.blobs.set(k, blob);
+      this.faces.set(k, face);
+      this.fonts.set(k, font);
+    } catch (err) {
+      throw new Error(
+        `Failed to register font "${desc.family}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
   }
   async getFont(desc) {
-    if (!this.hb) await this.init();
-    const k = this.key(desc);
-    const f = this.fonts.get(k);
-    if (!f) throw new Error(`Font not registered for ${k}`);
-    return f;
+    try {
+      if (!this.hb) await this.init();
+      const k = this.key(desc);
+      const f = this.fonts.get(k);
+      if (!f) throw new Error(`Font not registered for ${k}`);
+      return f;
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("Font not registered")) {
+        throw err;
+      }
+      throw new Error(
+        `Failed to get font "${desc.family}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
   }
   async getFace(desc) {
-    if (!this.hb) await this.init();
-    const k = this.key(desc);
-    return this.faces.get(k);
+    try {
+      if (!this.hb) await this.init();
+      const k = this.key(desc);
+      return this.faces.get(k);
+    } catch (err) {
+      throw new Error(
+        `Failed to get face for "${desc.family}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
   }
   async getUnitsPerEm(desc) {
-    const face = await this.getFace(desc);
-    return face?.upem || 1e3;
+    try {
+      const face = await this.getFace(desc);
+      return face?.upem || 1e3;
+    } catch (err) {
+      throw new Error(
+        `Failed to get units per em for "${desc.family}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
   }
   async glyphPath(desc, glyphId) {
-    const font = await this.getFont(desc);
-    const path = font.glyphToPath(glyphId);
-    return path && path !== "" ? path : "M 0 0";
+    try {
+      const font = await this.getFont(desc);
+      const path = font.glyphToPath(glyphId);
+      return path && path !== "" ? path : "M 0 0";
+    } catch (err) {
+      throw new Error(
+        `Failed to get glyph path for glyph ${glyphId} in font "${desc.family}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
   }
   destroy() {
-    for (const [, f] of this.fonts) f.destroy?.();
-    for (const [, f] of this.faces) f.destroy?.();
-    for (const [, b] of this.blobs) b.destroy?.();
-    this.fonts.clear();
-    this.faces.clear();
-    this.blobs.clear();
-    this.hb = void 0;
-    this.initPromise = void 0;
+    try {
+      for (const [, f] of this.fonts) {
+        try {
+          f.destroy();
+        } catch (err) {
+          console.error(
+            `Error destroying font: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      for (const [, f] of this.faces) {
+        try {
+          f.destroy();
+        } catch (err) {
+          console.error(
+            `Error destroying face: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      for (const [, b] of this.blobs) {
+        try {
+          b.destroy();
+        } catch (err) {
+          console.error(
+            `Error destroying blob: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      this.fonts.clear();
+      this.faces.clear();
+      this.blobs.clear();
+      this.hb = void 0;
+      this.initPromise = void 0;
+    } catch (err) {
+      console.error(
+        `Error during FontRegistry cleanup: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
   }
 };
 
@@ -282,112 +368,145 @@ var LayoutEngine = class {
     }
   }
   async shapeFull(text, desc) {
-    const hb = await this.fonts.getHB();
-    const buffer = hb.createBuffer();
-    buffer.addText(text);
-    buffer.guessSegmentProperties();
-    const font = await this.fonts.getFont(desc);
-    const face = await this.fonts.getFace(desc);
-    const upem = face?.upem || 1e3;
-    font.setScale(upem, upem);
-    hb.shape(font, buffer);
-    const result = buffer.json();
-    buffer.destroy();
-    return result;
+    try {
+      const hb = await this.fonts.getHB();
+      const buffer = hb.createBuffer();
+      try {
+        buffer.addText(text);
+        buffer.guessSegmentProperties();
+        const font = await this.fonts.getFont(desc);
+        const face = await this.fonts.getFace(desc);
+        const upem = face?.upem || 1e3;
+        font.setScale(upem, upem);
+        hb.shape(font, buffer);
+        const result = buffer.json();
+        return result;
+      } finally {
+        try {
+          buffer.destroy();
+        } catch (err) {
+          console.error(
+            `Error destroying HarfBuzz buffer: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    } catch (err) {
+      throw new Error(
+        `Failed to shape text with font "${desc.family}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
   }
   async layout(params) {
-    const { textTransform, desc, fontSize, letterSpacing, width } = params;
-    const input = this.transformText(params.text, textTransform);
-    if (!input || input.length === 0) {
-      return [];
-    }
-    const shaped = await this.shapeFull(input, desc);
-    const face = await this.fonts.getFace(desc);
-    const upem = face?.upem || 1e3;
-    const scale = fontSize / upem;
-    const glyphs = shaped.map((g) => {
-      const charIndex = g.cl;
-      let char;
-      if (charIndex >= 0 && charIndex < input.length) {
-        char = input[charIndex];
+    try {
+      const { textTransform, desc, fontSize, letterSpacing, width } = params;
+      const input = this.transformText(params.text, textTransform);
+      if (!input || input.length === 0) {
+        return [];
       }
-      return {
-        id: g.g,
-        xAdvance: g.ax * scale + letterSpacing,
-        xOffset: g.dx * scale,
-        yOffset: -g.dy * scale,
-        cluster: g.cl,
-        char
-        // This now correctly maps to the original character
-      };
-    });
-    const lines = [];
-    let currentLine = [];
-    let currentWidth = 0;
-    const spaceIndices = /* @__PURE__ */ new Set();
-    for (let i = 0; i < input.length; i++) {
-      if (input[i] === " ") {
-        spaceIndices.add(i);
+      let shaped;
+      try {
+        shaped = await this.shapeFull(input, desc);
+      } catch (err) {
+        throw new Error(`Text shaping failed: ${err instanceof Error ? err.message : String(err)}`);
       }
-    }
-    let lastBreakIndex = -1;
-    for (let i = 0; i < glyphs.length; i++) {
-      const glyph = glyphs[i];
-      const glyphWidth = glyph.xAdvance;
-      if (glyph.char === "\n") {
-        if (currentLine.length > 0) {
-          lines.push({
-            glyphs: currentLine,
-            width: currentWidth,
-            y: 0
-          });
+      let upem;
+      try {
+        const face = await this.fonts.getFace(desc);
+        upem = face?.upem || 1e3;
+      } catch (err) {
+        throw new Error(
+          `Failed to get font metrics: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      const scale = fontSize / upem;
+      const glyphs = shaped.map((g) => {
+        const charIndex = g.cl;
+        let char;
+        if (charIndex >= 0 && charIndex < input.length) {
+          char = input[charIndex];
+        }
+        return {
+          id: g.g,
+          xAdvance: g.ax * scale + letterSpacing,
+          xOffset: g.dx * scale,
+          yOffset: -g.dy * scale,
+          cluster: g.cl,
+          char
+        };
+      });
+      const lines = [];
+      let currentLine = [];
+      let currentWidth = 0;
+      const spaceIndices = /* @__PURE__ */ new Set();
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === " ") {
+          spaceIndices.add(i);
         }
-        currentLine = [];
-        currentWidth = 0;
-        lastBreakIndex = i;
-        continue;
       }
-      if (currentWidth + glyphWidth > width && currentLine.length > 0) {
-        if (lastBreakIndex > -1) {
-          const breakPoint = lastBreakIndex - (i - currentLine.length) + 1;
-          const nextLine = currentLine.splice(breakPoint);
-          const lineWidth = currentLine.reduce((sum, g) => sum + g.xAdvance, 0);
-          lines.push({
-            glyphs: currentLine,
-            width: lineWidth,
-            y: 0
-          });
-          currentLine = nextLine;
-          currentWidth = nextLine.reduce((sum, g) => sum + g.xAdvance, 0);
-        } else {
-          lines.push({
-            glyphs: currentLine,
-            width: currentWidth,
-            y: 0
-          });
+      let lastBreakIndex = -1;
+      for (let i = 0; i < glyphs.length; i++) {
+        const glyph = glyphs[i];
+        const glyphWidth = glyph.xAdvance;
+        if (glyph.char === "\n") {
+          if (currentLine.length > 0) {
+            lines.push({
+              glyphs: currentLine,
+              width: currentWidth,
+              y: 0
+            });
+          }
           currentLine = [];
           currentWidth = 0;
+          lastBreakIndex = i;
+          continue;
+        }
+        if (currentWidth + glyphWidth > width && currentLine.length > 0) {
+          if (lastBreakIndex > -1) {
+            const breakPoint = lastBreakIndex - (i - currentLine.length) + 1;
+            const nextLine = currentLine.splice(breakPoint);
+            const lineWidth = currentLine.reduce((sum, g) => sum + g.xAdvance, 0);
+            lines.push({
+              glyphs: currentLine,
+              width: lineWidth,
+              y: 0
+            });
+            currentLine = nextLine;
+            currentWidth = nextLine.reduce((sum, g) => sum + g.xAdvance, 0);
+          } else {
+            lines.push({
+              glyphs: currentLine,
+              width: currentWidth,
+              y: 0
+            });
+            currentLine = [];
+            currentWidth = 0;
+          }
+          lastBreakIndex = -1;
+        }
+        currentLine.push(glyph);
+        currentWidth += glyphWidth;
+        if (spaceIndices.has(glyph.cluster)) {
+          lastBreakIndex = i;
         }
-        lastBreakIndex = -1;
       }
-      currentLine.push(glyph);
-      currentWidth += glyphWidth;
-      if (spaceIndices.has(glyph.cluster)) {
-        lastBreakIndex = i;
+      if (currentLine.length > 0) {
+        lines.push({
+          glyphs: currentLine,
+          width: currentWidth,
+          y: 0
+        });
       }
+      const lineHeight = params.lineHeight * fontSize;
+      for (let i = 0; i < lines.length; i++) {
+        lines[i].y = (i + 1) * lineHeight;
+      }
+      return lines;
+    } catch (err) {
+      if (err instanceof Error) {
+        throw err;
+      }
+      throw new Error(`Layout failed: ${String(err)}`);
     }
-    if (currentLine.length > 0) {
-      lines.push({
-        glyphs: currentLine,
-        width: currentWidth,
-        y: 0
-      });
-    }
-    const lineHeight = params.lineHeight * fontSize;
-    for (let i = 0; i < lines.length; i++) {
-      lines[i].y = (i + 1) * lineHeight;
-    }
-    return lines;
   }
 };
 
@@ -479,7 +598,6 @@ async function buildDrawOps(p) {
           path,
           x: glyphX + p.shadow.offsetX,
           y: glyphY + p.shadow.offsetY,
-          // @ts-ignore scale propagated to painters
           scale,
           fill: { kind: "solid", color: p.shadow.color, opacity: p.shadow.opacity }
         });
@@ -490,7 +608,6 @@ async function buildDrawOps(p) {
           path,
           x: glyphX,
           y: glyphY,
-          // @ts-ignore scale propagated to painters
           scale,
           width: p.stroke.width,
           color: p.stroke.color,
@@ -502,7 +619,6 @@ async function buildDrawOps(p) {
         path,
         x: glyphX,
         y: glyphY,
-        // @ts-ignore scale propagated to painters
         scale,
         fill
       });
@@ -1078,30 +1194,32 @@ async function createNodePainter(opts) {
           continue;
         }
         if (op.op === "FillPath") {
+          const fillOp = op;
           ctx.save();
-          ctx.translate(op.x, op.y);
-          const s = op.scale ?? 1;
+          ctx.translate(fillOp.x, fillOp.y);
+          const s = fillOp.scale ?? 1;
           ctx.scale(s, -s);
           ctx.beginPath();
-          drawSvgPathOnCtx(ctx, op.path);
-          const bbox = op.gradientBBox ?? globalBox;
-          const fill = makeGradientFromBBox(ctx, op.fill, bbox);
+          drawSvgPathOnCtx(ctx, fillOp.path);
+          const bbox = fillOp.gradientBBox ?? globalBox;
+          const fill = makeGradientFromBBox(ctx, fillOp.fill, bbox);
           ctx.fillStyle = fill;
           ctx.fill();
           ctx.restore();
           continue;
         }
         if (op.op === "StrokePath") {
+          const strokeOp = op;
           ctx.save();
-          ctx.translate(op.x, op.y);
-          const s = op.scale ?? 1;
+          ctx.translate(strokeOp.x, strokeOp.y);
+          const s = strokeOp.scale ?? 1;
           ctx.scale(s, -s);
           const invAbs = 1 / Math.abs(s);
           ctx.beginPath();
-          drawSvgPathOnCtx(ctx, op.path);
-          const c = parseHex6(op.color, op.opacity);
+          drawSvgPathOnCtx(ctx, strokeOp.path);
+          const c = parseHex6(strokeOp.color, strokeOp.opacity);
           ctx.strokeStyle = `rgba(${c.r},${c.g},${c.b},${c.a})`;
-          ctx.lineWidth = op.width * invAbs;
+          ctx.lineWidth = strokeOp.width * invAbs;
           ctx.lineJoin = "round";
           ctx.lineCap = "round";
           ctx.stroke();
@@ -1133,17 +1251,20 @@ function makeGradientFromBBox(ctx, spec, box) {
     const c = parseHex6(spec.color, spec.opacity);
     return `rgba(${c.r},${c.g},${c.b},${c.a})`;
   }
-  const cx = box.x + box.w / 2, cy = box.y + box.h / 2, r = Math.max(box.w, box.h) / 2;
+  const cx = box.x + box.w / 2;
+  const cy = box.y + box.h / 2;
+  const r = Math.max(box.w, box.h) / 2;
   const addStops = (g) => {
-    const op = spec.opacity ?? 1;
-    for (const s of spec.stops) {
-      const c = parseHex6(s.color, op);
+    const opacity = spec.kind === "linear" || spec.kind === "radial" ? spec.opacity : 1;
+    const stops = spec.kind === "linear" || spec.kind === "radial" ? spec.stops : [];
+    for (const s of stops) {
+      const c = parseHex6(s.color, opacity);
       g.addColorStop(s.offset, `rgba(${c.r},${c.g},${c.b},${c.a})`);
     }
     return g;
   };
   if (spec.kind === "linear") {
-    const rad = (spec.angle || 0) * Math.PI / 180;
+    const rad = spec.angle * Math.PI / 180;
     const x1 = cx + Math.cos(rad + Math.PI) * r;
     const y1 = cy + Math.sin(rad + Math.PI) * r;
     const x2 = cx + Math.cos(rad) * r;
@@ -1154,22 +1275,34 @@ function makeGradientFromBBox(ctx, spec, box) {
   }
 }
 function computeGlobalTextBounds(ops) {
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
   for (const op of ops) {
-    if (op.op !== "FillPath" || op.isShadow) continue;
-    const b = computePathBounds2(op.path);
-    const s = op.scale ?? 1;
-    const x1 = op.x + s * b.x;
-    const x2 = op.x + s * (b.x + b.w);
-    const y1 = op.y - s * (b.y + b.h);
-    const y2 = op.y - s * b.y;
+    if (op.op !== "FillPath") continue;
+    const fillOp = op;
+    if (fillOp.isShadow) continue;
+    const b = computePathBounds2(fillOp.path);
+    const s = fillOp.scale ?? 1;
+    const x1 = fillOp.x + s * b.x;
+    const x2 = fillOp.x + s * (b.x + b.w);
+    const y1 = fillOp.y - s * (b.y + b.h);
+    const y2 = fillOp.y - s * b.y;
     if (x1 < minX) minX = x1;
     if (y1 < minY) minY = y1;
     if (x2 > maxX) maxX = x2;
     if (y2 > maxY) maxY = y2;
   }
-  if (minX === Infinity) return { x: 0, y: 0, w: 1, h: 1 };
-  return { x: minX, y: minY, w: Math.max(1, maxX - minX), h: Math.max(1, maxY - minY) };
+  if (minX === Infinity) {
+    return { x: 0, y: 0, w: 1, h: 1 };
+  }
+  return {
+    x: minX,
+    y: minY,
+    w: Math.max(1, maxX - minX),
+    h: Math.max(1, maxY - minY)
+  };
 }
 function drawSvgPathOnCtx(ctx, d) {
   const t = tokenizePath2(d);
@@ -1211,13 +1344,18 @@ function drawSvgPathOnCtx(ctx, d) {
         ctx.closePath();
         break;
       }
+      default:
+        break;
     }
   }
 }
 function computePathBounds2(d) {
   const t = tokenizePath2(d);
   let i = 0;
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
   const touch = (x, y) => {
     if (x < minX) minX = x;
     if (y < minY) minY = y;
@@ -1257,10 +1395,19 @@ function computePathBounds2(d) {
       }
       case "Z":
         break;
+      default:
+        break;
     }
   }
-  if (minX === Infinity) return { x: 0, y: 0, w: 0, h: 0 };
-  return { x: minX, y: minY, w: maxX - minX, h: maxY - minY };
+  if (minX === Infinity) {
+    return { x: 0, y: 0, w: 0, h: 0 };
+  }
+  return {
+    x: minX,
+    y: minY,
+    w: maxX - minX,
+    h: maxY - minY
+  };
 }
 function roundRectPath(ctx, x, y, w, h, r) {
   ctx.moveTo(x + r, y);
@@ -1289,20 +1436,54 @@ function bufferToArrayBuffer(buf) {
   return ab.slice(byteOffset, byteOffset + byteLength);
 }
 async function loadFileOrHttpToArrayBuffer(pathOrUrl) {
-  if (/^https?:\/\//.test(pathOrUrl)) {
-    const client = pathOrUrl.startsWith("https:") ? https : http;
-    const buf2 = await new Promise((resolve, reject) => {
-      client.get(pathOrUrl, (res) => {
-        const chunks = [];
-        res.on("data", (d) => chunks.push(d));
-        res.on("end", () => resolve(Buffer.concat(chunks)));
-        res.on("error", reject);
-      }).on("error", reject);
-    });
-    return bufferToArrayBuffer(buf2);
+  try {
+    if (/^https?:\/\//.test(pathOrUrl)) {
+      const client = pathOrUrl.startsWith("https:") ? https : http;
+      const buf2 = await new Promise((resolve, reject) => {
+        const request = client.get(pathOrUrl, (res) => {
+          const { statusCode } = res;
+          if (statusCode && (statusCode < 200 || statusCode >= 300)) {
+            reject(new Error(`HTTP request failed with status ${statusCode} for ${pathOrUrl}`));
+            res.resume();
+            return;
+          }
+          const chunks = [];
+          res.on("data", (chunk) => {
+            chunks.push(chunk);
+          });
+          res.on("end", () => {
+            try {
+              resolve(Buffer.concat(chunks));
+            } catch (err) {
+              reject(
+                new Error(
+                  `Failed to concatenate response chunks: ${err instanceof Error ? err.message : String(err)}`
+                )
+              );
+            }
+          });
+          res.on("error", (err) => {
+            reject(new Error(`Response error for ${pathOrUrl}: ${err.message}`));
+          });
+        });
+        request.on("error", (err) => {
+          reject(new Error(`Request error for ${pathOrUrl}: ${err.message}`));
+        });
+        request.setTimeout(3e4, () => {
+          request.destroy();
+          reject(new Error(`Request timeout after 30s for ${pathOrUrl}`));
+        });
+      });
+      return bufferToArrayBuffer(buf2);
+    }
+    const buf = await (0, import_promises.readFile)(pathOrUrl);
+    return bufferToArrayBuffer(buf);
+  } catch (err) {
+    if (err instanceof Error) {
+      throw new Error(`Failed to load ${pathOrUrl}: ${err.message}`);
+    }
+    throw new Error(`Failed to load ${pathOrUrl}: ${String(err)}`);
   }
-  const buf = await (0, import_promises.readFile)(pathOrUrl);
-  return bufferToArrayBuffer(buf);
 }
 
 // src/core/video-generator.ts
@@ -1438,6 +1619,14 @@ var VideoGenerator = class {
   }
 };
 
+// src/types.ts
+var isShadowFill2 = (op) => {
+  return op.op === "FillPath" && op.isShadow === true;
+};
+var isGlyphFill2 = (op) => {
+  return op.op === "FillPath" && op.isShadow !== true;
+};
+
 // src/env/entry.node.ts
 async function createTextEngine(opts = {}) {
   const width = opts.width ?? CANVAS_CONFIG.DEFAULTS.width;
@@ -1448,126 +1637,214 @@ async function createTextEngine(opts = {}) {
   const fonts = new FontRegistry(wasmBaseURL);
   const layout = new LayoutEngine(fonts);
   const videoGenerator = new VideoGenerator();
-  await fonts.init();
+  try {
+    await fonts.init();
+  } catch (err) {
+    throw new Error(
+      `Failed to initialize font registry: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
   async function ensureFonts(asset) {
-    if (asset.customFonts) {
-      for (const cf of asset.customFonts) {
-        const bytes = await loadFileOrHttpToArrayBuffer(cf.src);
-        await fonts.registerFromBytes(bytes, {
-          family: cf.family,
-          weight: cf.weight ?? "400",
-          style: cf.style ?? "normal"
-        });
+    try {
+      if (asset.customFonts) {
+        for (const cf of asset.customFonts) {
+          try {
+            const bytes = await loadFileOrHttpToArrayBuffer(cf.src);
+            await fonts.registerFromBytes(bytes, {
+              family: cf.family,
+              weight: cf.weight ?? "400",
+              style: cf.style ?? "normal"
+            });
+          } catch (err) {
+            throw new Error(
+              `Failed to load custom font "${cf.family}" from ${cf.src}: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      }
+      const main = asset.font ?? {
+        family: "Roboto",
+        weight: "400",
+        style: "normal",
+        size: 48,
+        color: "#000000",
+        opacity: 1
+      };
+      return main;
+    } catch (err) {
+      if (err instanceof Error) {
+        throw err;
       }
+      throw new Error(`Failed to ensure fonts: ${String(err)}`);
     }
-    const main = asset.font ?? {
-      family: "Roboto",
-      weight: "400",
-      style: "normal",
-      size: 48,
-      color: "#000000",
-      opacity: 1
-    };
-    return main;
   }
   return {
     validate(input) {
-      const { value, error } = RichTextAssetSchema.validate(input, {
-        abortEarly: false,
-        convert: true
-      });
-      if (error) throw error;
-      return { value };
+      try {
+        const { value, error } = RichTextAssetSchema.validate(input, {
+          abortEarly: false,
+          convert: true
+        });
+        if (error) throw error;
+        return { value };
+      } catch (err) {
+        if (err instanceof Error) {
+          throw new Error(`Validation failed: ${err.message}`);
+        }
+        throw new Error(`Validation failed: ${String(err)}`);
+      }
     },
     async registerFontFromFile(path, desc) {
-      const bytes = await loadFileOrHttpToArrayBuffer(path);
-      await fonts.registerFromBytes(bytes, desc);
+      try {
+        const bytes = await loadFileOrHttpToArrayBuffer(path);
+        await fonts.registerFromBytes(bytes, desc);
+      } catch (err) {
+        throw new Error(
+          `Failed to register font "${desc.family}" from file ${path}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
     },
     async registerFontFromUrl(url, desc) {
-      const bytes = await loadFileOrHttpToArrayBuffer(url);
-      await fonts.registerFromBytes(bytes, desc);
+      try {
+        const bytes = await loadFileOrHttpToArrayBuffer(url);
+        await fonts.registerFromBytes(bytes, desc);
+      } catch (err) {
+        throw new Error(
+          `Failed to register font "${desc.family}" from URL ${url}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
     },
     async renderFrame(asset, tSeconds) {
-      const main = await ensureFonts(asset);
-      const desc = { family: main.family, weight: `${main.weight}`, style: main.style };
-      const lines = await layout.layout({
-        text: asset.text,
-        width: asset.width ?? width,
-        letterSpacing: asset.style?.letterSpacing ?? 0,
-        fontSize: main.size,
-        lineHeight: asset.style?.lineHeight ?? 1.2,
-        desc,
-        textTransform: asset.style?.textTransform ?? "none"
-      });
-      const textRect = { x: 0, y: 0, width: asset.width ?? width, height: asset.height ?? height };
-      const canvasW = asset.width ?? width;
-      const canvasH = asset.height ?? height;
-      const canvasPR = asset.pixelRatio ?? pixelRatio;
-      const ops0 = await buildDrawOps({
-        canvas: { width: canvasW, height: canvasH, pixelRatio: canvasPR },
-        textRect,
-        lines,
-        font: {
-          family: main.family,
-          size: main.size,
-          weight: `${main.weight}`,
-          style: main.style,
-          color: main.color,
-          opacity: main.opacity
-        },
-        style: {
-          lineHeight: asset.style?.lineHeight ?? 1.2,
-          textDecoration: asset.style?.textDecoration ?? "none",
-          gradient: asset.style?.gradient
-        },
-        stroke: asset.stroke,
-        shadow: asset.shadow,
-        align: asset.align ?? { horizontal: "left", vertical: "middle" },
-        background: asset.background,
-        glyphPathProvider: (gid) => fonts.glyphPath(desc, gid),
-        getUnitsPerEm: () => fonts.getUnitsPerEm(desc)
-      });
-      const ops = applyAnimation(ops0, lines, {
-        t: tSeconds,
-        fontSize: main.size,
-        anim: asset.animation ? {
-          preset: asset.animation.preset,
-          speed: asset.animation.speed,
-          duration: asset.animation.duration,
-          style: asset.animation.style,
-          direction: asset.animation.direction
-        } : void 0
-      });
-      return ops;
+      try {
+        const main = await ensureFonts(asset);
+        const desc = { family: main.family, weight: `${main.weight}`, style: main.style };
+        let lines;
+        try {
+          lines = await layout.layout({
+            text: asset.text,
+            width: asset.width ?? width,
+            letterSpacing: asset.style?.letterSpacing ?? 0,
+            fontSize: main.size,
+            lineHeight: asset.style?.lineHeight ?? 1.2,
+            desc,
+            textTransform: asset.style?.textTransform ?? "none"
+          });
+        } catch (err) {
+          throw new Error(
+            `Failed to layout text: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        const textRect = {
+          x: 0,
+          y: 0,
+          width: asset.width ?? width,
+          height: asset.height ?? height
+        };
+        const canvasW = asset.width ?? width;
+        const canvasH = asset.height ?? height;
+        const canvasPR = asset.pixelRatio ?? pixelRatio;
+        let ops0;
+        try {
+          ops0 = await buildDrawOps({
+            canvas: { width: canvasW, height: canvasH, pixelRatio: canvasPR },
+            textRect,
+            lines,
+            font: {
+              family: main.family,
+              size: main.size,
+              weight: `${main.weight}`,
+              style: main.style,
+              color: main.color,
+              opacity: main.opacity
+            },
+            style: {
+              lineHeight: asset.style?.lineHeight ?? 1.2,
+              textDecoration: asset.style?.textDecoration ?? "none",
+              gradient: asset.style?.gradient
+            },
+            stroke: asset.stroke,
+            shadow: asset.shadow,
+            align: asset.align ?? { horizontal: "left", vertical: "middle" },
+            background: asset.background,
+            glyphPathProvider: (gid) => fonts.glyphPath(desc, gid),
+            getUnitsPerEm: () => fonts.getUnitsPerEm(desc)
+          });
+        } catch (err) {
+          throw new Error(
+            `Failed to build draw operations: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        try {
+          const ops = applyAnimation(ops0, lines, {
+            t: tSeconds,
+            fontSize: main.size,
+            anim: asset.animation ? {
+              preset: asset.animation.preset,
+              speed: asset.animation.speed,
+              duration: asset.animation.duration,
+              style: asset.animation.style,
+              direction: asset.animation.direction
+            } : void 0
+          });
+          return ops;
+        } catch (err) {
+          throw new Error(
+            `Failed to apply animation: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      } catch (err) {
+        if (err instanceof Error) {
+          throw err;
+        }
+        throw new Error(`Failed to render frame at time ${tSeconds}s: ${String(err)}`);
+      }
     },
     async createRenderer(p) {
-      return createNodePainter({
-        width: p.width ?? width,
-        height: p.height ?? height,
-        pixelRatio: p.pixelRatio ?? pixelRatio
-      });
+      try {
+        return await createNodePainter({
+          width: p.width ?? width,
+          height: p.height ?? height,
+          pixelRatio: p.pixelRatio ?? pixelRatio
+        });
+      } catch (err) {
+        throw new Error(
+          `Failed to create renderer: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
     },
     async generateVideo(asset, options) {
-      const finalOptions = {
-        width: asset.width ?? width,
-        height: asset.height ?? height,
-        fps,
-        duration: asset.animation?.duration ?? 3,
-        outputPath: options.outputPath ?? "output.mp4",
-        pixelRatio: asset.pixelRatio ?? pixelRatio
-      };
-      const frameGenerator = async (time) => {
-        return this.renderFrame(asset, time);
-      };
-      await videoGenerator.generateVideo(frameGenerator, finalOptions);
+      try {
+        const finalOptions = {
+          width: asset.width ?? width,
+          height: asset.height ?? height,
+          fps,
+          duration: asset.animation?.duration ?? 3,
+          outputPath: options.outputPath ?? "output.mp4",
+          pixelRatio: asset.pixelRatio ?? pixelRatio
+        };
+        const frameGenerator = async (time) => {
+          return this.renderFrame(asset, time);
+        };
+        await videoGenerator.generateVideo(frameGenerator, finalOptions);
+      } catch (err) {
+        throw new Error(
+          `Failed to generate video: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
     },
     destroy() {
-      fonts.destroy();
+      try {
+        fonts.destroy();
+      } catch (err) {
+        console.error(`Error during cleanup: ${err instanceof Error ? err.message : String(err)}`);
+      }
     }
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createTextEngine
+  createTextEngine,
+  isGlyphFill,
+  isShadowFill
 });
 //# sourceMappingURL=entry.node.cjs.map