Upload 7 files

app/api/shadow.js

@@ -0,0 +1,142 @@
+// const express = require('express');
+// const multer = require('multer');
+// const { generateShadow } = require('../core/shadowGenerator');
+
+// const router = express.Router();
+
+// // Store file in memory (not on disk)
+// const storage = multer.memoryStorage();
+// const upload = multer({ storage });
+
+// // POST /api/shadow/generate
+// router.post('/generate', upload.single('image'), async (req, res) => {
+//   try {
+//     if (!req.file) {
+//       return res.status(400).json({ success: false, error: 'No image uploaded' });
+//     }
+
+//     const options = {
+//       type: req.body.type || 'cast',         // 'cast' | 'drop' | 'flat' | 'box'
+//       dir: req.body.dir || 'back',           // used only for drop/flat/box
+//       blur: parseInt(req.body.blur) || 20,
+//       opacity: parseFloat(req.body.opacity) || 0.4,
+//       lightX: req.body.lightX ? parseInt(req.body.lightX) : null,
+//       lightY: req.body.lightY ? parseInt(req.body.lightY) : null
+//     };
+
+//     const buffer = await generateShadow(req.file.buffer, options);
+
+//     // Send back as image/png directly
+//     res.set('Content-Type', 'image/png');
+//     res.send(buffer);
+
+//   } catch (err) {
+//     console.error('❌ Shadow generation error:', err);
+//     res.status(500).json({ success: false, error: 'Shadow generation failed' });
+//   }
+// });
+
+// module.exports = router;
+
+
+// const express = require('express');
+// const multer = require('multer');
+// const { generateShadow } = require('../core/shadowGenerator');
+
+// const router = express.Router();
+
+// // Use memory storage for uploaded file
+// const storage = multer.memoryStorage();
+// const upload = multer({ storage });
+
+// router.post('/generate', upload.single('image'), async (req, res) => {
+//   try {
+//     if (!req.file) {
+//       return res.status(400).json({ success: false, error: 'No image uploaded' });
+//     }
+
+//     // Parse options correctly
+//     const options = {
+//       type: req.body.mode || 'cast',           // match frontend "mode"
+//       dir: req.body.dir || 'back',
+//       blur: req.body.blur ? parseFloat(req.body.blur) : 20,   // ensure number
+//       opacity: req.body.opacity ? parseFloat(req.body.opacity) : 0.35,
+//       lightX: req.body.lightX ? parseFloat(req.body.lightX) : null,
+//       lightY: req.body.lightY ? parseFloat(req.body.lightY) : null
+//     };
+
+//     const buffer = await generateShadow(req.file.buffer, options);
+
+//     res.set('Content-Type', 'image/png');
+//     res.send(buffer);
+
+//   } catch (err) {
+//     console.error('❌ Shadow generation error:', err);
+//     res.status(500).json({ success: false, error: 'Shadow generation failed' });
+//   }
+// });
+
+// module.exports = router;
+
+
+
+const express = require('express');
+const multer = require('multer');
+const {
+  addTask,
+  getTaskStatus,
+  getTaskResult,
+  getQueueLength
+} = require('../../queue');
+
+const router = express.Router();
+const upload = multer({ storage: multer.memoryStorage() });
+
+// ---------------- Submit new shadow task ----------------
+router.post('/add-shadow', upload.single('file'), async (req, res) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({ error: 'No image uploaded' });
+    }
+
+    const options = {
+      type: req.body.type || 'cast',
+      dir: req.body.dir || 'back',
+      blur: req.body.blur ? parseFloat(req.body.blur) : 20,
+      opacity: req.body.opacity ? parseFloat(req.body.opacity) : 0.35,
+      lightX: req.body.lightX ? parseFloat(req.body.lightX) : null,
+      lightY: req.body.lightY ? parseFloat(req.body.lightY) : null,
+    };
+
+    const taskId = await addTask(req.file.buffer, options);
+    res.json({ task_id: taskId });
+  } catch (err) {
+    console.error('❌ Error adding shadow task:', err);
+    res.status(500).json({ error: 'Failed to add shadow task' });
+  }
+});
+
+// ---------------- Queue status ----------------
+router.get('/status', (req, res) => {
+  res.json({
+    status: 'ok',
+    queue_length: getQueueLength(),
+  });
+});
+
+// ---------------- Fetch result ----------------
+router.get('/result/:id', (req, res) => {
+  const taskId = req.params.id;
+  const status = getTaskStatus(taskId);
+
+  if (status === 'pending') return res.sendStatus(202);
+  if (status === 'failed') return res.status(500).json({ error: 'Shadow generation failed' });
+
+  const result = getTaskResult(taskId);
+  if (!result) return res.status(404).json({ error: 'Result not found' });
+
+  res.set('Content-Type', 'image/png');
+  res.send(result);
+});
+
+module.exports = router;

app/core/shadowGenerator.js

@@ -0,0 +1,1627 @@
+// const { createCanvas, loadImage } = require('canvas');
+// const path = require('path');
+// const fs = require('fs');
+
+// /**
+//  * Generate shadow for a PNG image
+//  * @param {string} imagePath - Path to input PNG
+//  * @param {object} options - { mode: 'drop'|'cast', dir: 'front'|'back'|'left'|'right', blur: number, opacity: number }
+//  * @returns {string} - Path to output shadowed image
+//  */
+// async function generateShadow(imagePath, options = {}) {
+//   const {
+//     mode = 'drop',
+//     dir = 'back',
+//     blur = 20,
+//     opacity = 0.4
+//   } = options;
+
+//   const img = await loadImage(imagePath);
+//   const w = img.width;
+//   const h = img.height;
+
+//   const canvas = createCanvas(w * 2, h * 2); // allow room for shadow
+//   const ctx = canvas.getContext('2d');
+
+//   ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+//   if (mode === 'drop') {
+//     drawDropShadow(ctx, img, w, h, dir, blur, opacity);
+//   } else {
+//     drawCastShadow(ctx, img, w, h, dir, blur, opacity);
+//   }
+
+//   // draw original image centered
+//   ctx.globalAlpha = 1;
+//   ctx.filter = 'none';
+//   ctx.drawImage(img, (canvas.width - w) / 2, (canvas.height - h) / 2, w, h);
+
+//   // save file
+//   const outPath = path.join(
+//     path.dirname(imagePath),
+//     `shadow_${Date.now()}.png`
+//   );
+//   const buffer = canvas.toBuffer('image/png');
+//   fs.writeFileSync(outPath, buffer);
+//   return outPath;
+// }
+
+// function drawDropShadow(ctx, img, w, h, dir, blur, opacity) {
+//   let dx = 0, dy = 0, offset = 40;
+//   if (dir === 'back') dy = offset;
+//   if (dir === 'front') dy = -offset;
+//   if (dir === 'left') dx = -offset;
+//   if (dir === 'right') dx = offset;
+
+//   ctx.save();
+//   ctx.filter = `blur(${blur}px)`;
+//   ctx.globalAlpha = opacity;
+//   ctx.drawImage(
+//     img,
+//     (ctx.canvas.width - w) / 2 + dx,
+//     (ctx.canvas.height - h) / 2 + dy,
+//     w,
+//     h
+//   );
+//   ctx.restore();
+// }
+
+// function drawCastShadow(ctx, img, w, h, dir, blur, opacity) {
+//   // make a shadow silhouette
+//   const temp = createCanvas(w, h);
+//   const tctx = temp.getContext('2d');
+//   tctx.drawImage(img, 0, 0, w, h);
+//   tctx.globalCompositeOperation = 'source-in';
+//   tctx.fillStyle = 'black';
+//   tctx.fillRect(0, 0, w, h);
+
+//   ctx.save();
+//   ctx.translate(ctx.canvas.width / 2, ctx.canvas.height * 0.85);
+//   let skewX = 0, stretchY = 1.5;
+//   if (dir === 'back') stretchY = 0.5;
+//   if (dir === 'front') stretchY = 2.0;
+//   if (dir === 'left') skewX = -0.8;
+//   if (dir === 'right') skewX = 0.8;
+
+//   ctx.transform(1, 0, skewX, stretchY * 0.3, 0, 0);
+//   ctx.globalAlpha = opacity;
+//   ctx.filter = `blur(${blur}px)`;
+//   ctx.drawImage(temp, -w / 2, -h, w, h);
+//   ctx.restore();
+// }
+
+// module.exports = { generateShadow };
+
+// const { createCanvas, loadImage } = require('canvas');
+
+// async function generateShadow(imageBuffer, options = {}) {
+//   const {
+//     type = 'cast',   // cast | drop | flat | box
+//     dir = 'back',    // used for non-cast
+//     blur = 8,
+//     opacity = 0.35,
+//     lightX,
+//     lightY
+//   } = options;
+
+//   const img = await loadImage(imageBuffer);
+//   const trimmed = trimImage(img);
+
+//   const W = 1000, H = 800;  // base canvas size (can be resized)
+//   const canvas = createCanvas(W, H);
+//   const ctx = canvas.getContext('2d');
+//   ctx.clearRect(0, 0, W, H);
+
+//   // Scale object to fit
+//   const maxW = W * 0.5;
+//   const maxH = H * 0.5;
+//   const scale = Math.min(maxW / trimmed.width, maxH / trimmed.height, 1);
+//   const scaledW = trimmed.width * scale;
+//   const scaledH = trimmed.height * scale;
+//   const baseY = H * 0.85;
+
+//   switch (type) {
+//     case 'drop':
+//       drawDropShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, blur, opacity, W, H, baseY);
+//       break;
+//     case 'flat':
+//       drawFlatShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, opacity, W, H, baseY);
+//       break;
+//     case 'box':
+//       drawBoxShadow(ctx, scaledW, scaledH, dir, blur, opacity, W, H, baseY);
+//       break;
+//     case 'cast':
+//     default:
+//       drawCastShadow(ctx, trimmed.canvas, scaledW, scaledH, blur, opacity, W, H, baseY, lightX, lightY, dir);
+//       break;
+//   }
+
+//   // Draw object on top
+//   ctx.globalAlpha = 1;
+//   ctx.filter = "none";
+//   ctx.drawImage(trimmed.canvas, (W - scaledW) / 2, baseY - scaledH, scaledW, scaledH);
+
+//   return canvas.toBuffer("image/png");
+// }
+
+// // ----------------- Shadow Types ------------------
+
+// function drawDropShadow(ctx, img, w, h, dir, blur, opacity, W, H, baseY) {
+//   let dx=0, dy=0, off=40;
+//   if (dir==='back') dy=off;
+//   if (dir==='front') dy=-off;
+//   if (dir==='left') dx=-off;
+//   if (dir==='right') dx=off;
+
+//   ctx.save();
+//   ctx.filter = `blur(${blur}px)`;
+//   ctx.globalAlpha = opacity;
+//   ctx.drawImage(img, (W-w)/2+dx, baseY-h+dy, w, h);
+//   ctx.restore();
+// }
+
+// function drawFlatShadow(ctx, img, w, h, dir, opacity, W, H, baseY) {
+//   let dx=0, dy=0, off=30;
+//   if (dir==='back') dy=off;
+//   if (dir==='front') dy=-off;
+//   if (dir==='left') dx=-off;
+//   if (dir==='right') dx=off;
+
+//   ctx.save();
+//   ctx.globalAlpha = opacity;
+//   ctx.drawImage(img, (W-w)/2+dx, baseY-h+dy, w, h);
+//   ctx.restore();
+// }
+
+// function drawBoxShadow(ctx, w, h, dir, blur, opacity, W, H, baseY) {
+//   let dx=0, dy=0, off=30;
+//   if (dir==='back') dy=off;
+//   if (dir==='front') dy=-off;
+//   if (dir==='left') dx=-off;
+//   if (dir==='right') dx=off;
+
+//   ctx.save();
+//   ctx.fillStyle = "rgba(0,0,0,0.3)";
+//   ctx.filter = `blur(${blur}px)`;
+//   ctx.fillRect((W-w)/2+dx, baseY-h+dy, w, h);
+//   ctx.restore();
+// }
+
+// function drawCastShadow(ctx, img, w, h, blur, opacity, W, H, baseY, lightX, lightY, dir) {
+//   const shadowCanvas = createCanvas(w, h);
+//   const sctx = shadowCanvas.getContext('2d');
+//   sctx.drawImage(img, 0, 0, w, h);
+//   sctx.globalCompositeOperation = "source-in";
+//   sctx.fillStyle = "black";
+//   sctx.fillRect(0, 0, w, h);
+
+//   // relative light (0 = top, 1 = bottom)
+//   const relX = lightX ? (lightX / W - 0.5) * 2 : (dir==='left'?-1:dir==='right'?1:0);
+//   const relY = lightY ? (lightY / H) : (dir==='front'?0.2:dir==='back'?0.8:0.5);
+
+//   const stretch = 1 + (1 - relY) * 2;
+//   const skew = relX * 0.8;
+
+//   ctx.save();
+//   ctx.translate(W/2, baseY);
+
+//   if (relY > 0.5 || dir === 'back') {
+//     // Light is behind → shadow comes forward
+//     ctx.transform(1, 0, skew, -stretch * 0.3, 0, 0);
+//     ctx.globalAlpha = opacity;
+//     ctx.filter = `blur(${blur}px)`;
+//     ctx.drawImage(shadowCanvas, -w/2, 0, w, h);
+//   } else {
+//     // Light in front/top → shadow behind
+//     ctx.transform(1, 0, skew, stretch * 0.3, 0, 0);
+//     ctx.globalAlpha = opacity;
+//     ctx.filter = `blur(${blur}px)`;
+//     ctx.drawImage(shadowCanvas, -w/2, -h, w, h);
+//   }
+
+//   ctx.restore();
+// }
+
+// // ----------------- Trimming ------------------
+
+// function trimImage(image) {
+//   const temp = createCanvas(image.width, image.height);
+//   const tctx = temp.getContext('2d');
+//   tctx.drawImage(image, 0, 0);
+//   const imgData = tctx.getImageData(0, 0, temp.width, temp.height);
+
+//   let top=temp.height, left=temp.width, right=0, bottom=0;
+//   for (let y=0;y<temp.height;y++) {
+//     for (let x=0;x<temp.width;x++) {
+//       const alpha = imgData.data[(y*temp.width+x)*4+3];
+//       if (alpha>0) {
+//         if (x<left) left=x;
+//         if (x>right) right=x;
+//         if (y<top) top=y;
+//         if (y>bottom) bottom=y;
+//       }
+//     }
+//   }
+
+//   const w = right-left+1;
+//   const h = bottom-top+1;
+//   const trimmedCanvas = createCanvas(w,h);
+//   const t2 = trimmedCanvas.getContext('2d');
+//   t2.drawImage(image, left, top, w, h, 0, 0, w, h);
+
+//   return { canvas: trimmedCanvas, width:w, height:h };
+// }
+
+// module.exports = { generateShadow };
+
+
+// const { createCanvas, loadImage } = require('canvas');
+
+// async function generateShadow(imageBuffer, options = {}) {
+//   const {
+//     type = 'cast',    // cast | drop | flat | box
+//     dir = 'back',     // back | front | left | right
+//     blur = 8,
+//     opacity = 0.35,
+//     lightX,           // optional custom light position
+//     lightY
+//   } = options;
+
+//   const img = await loadImage(imageBuffer);
+//   const trimmed = trimImage(img);
+
+//   const W = 1000, H = 800;        // base canvas size
+//   const canvas = createCanvas(W, H);
+//   const ctx = canvas.getContext('2d');
+//   ctx.clearRect(0, 0, W, H);
+
+//   // Scale object to fit canvas
+//   const maxW = W * 0.5;
+//   const maxH = H * 0.5;
+//   const scale = Math.min(maxW / trimmed.width, maxH / trimmed.height, 1);
+//   const scaledW = trimmed.width * scale;
+//   const scaledH = trimmed.height * scale;
+//   const baseY = H * 0.85;
+
+//   // Draw shadow
+//   switch (type) {
+//     case 'drop':
+//       drawDropShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, blur, opacity, W, H, baseY);
+//       break;
+//     case 'flat':
+//       drawFlatShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, opacity, W, H, baseY);
+//       break;
+//     case 'box':
+//       drawBoxShadow(ctx, scaledW, scaledH, dir, blur, opacity, W, H, baseY);
+//       break;
+//     case 'cast':
+//     default:
+//       drawCastShadow(ctx, trimmed.canvas, scaledW, scaledH, blur, opacity, W, H, baseY, lightX, lightY, dir);
+//       break;
+//   }
+
+//   // Draw object on top
+//   ctx.globalAlpha = 1;
+//   ctx.filter = "none";
+//   ctx.drawImage(trimmed.canvas, (W - scaledW) / 2, baseY - scaledH, scaledW, scaledH);
+
+//   return canvas.toBuffer("image/png");
+// }
+
+// // ----------------- Shadow Types ------------------
+
+// function drawDropShadow(ctx, img, w, h, dir, blur, opacity, W, H, baseY) {
+//   let dx = 0, dy = 0, off = 40;
+//   if (dir === 'back') dy = off;
+//   if (dir === 'front') dy = -off;
+//   if (dir === 'left') dx = -off;
+//   if (dir === 'right') dx = off;
+
+//   ctx.save();
+//   ctx.filter = `blur(${blur}px)`;
+//   ctx.globalAlpha = opacity;
+//   ctx.drawImage(img, (W - w) / 2 + dx, baseY - h + dy, w, h);
+//   ctx.restore();
+// }
+
+// function drawFlatShadow(ctx, img, w, h, dir, opacity, W, H, baseY) {
+//   let dx = 0, dy = 0, off = 30;
+//   if (dir === 'back') dy = off;
+//   if (dir === 'front') dy = -off;
+//   if (dir === 'left') dx = -off;
+//   if (dir === 'right') dx = off;
+
+//   ctx.save();
+//   ctx.globalAlpha = opacity;
+//   ctx.drawImage(img, (W - w) / 2 + dx, baseY - h + dy, w, h);
+//   ctx.restore();
+// }
+
+// function drawBoxShadow(ctx, w, h, dir, blur, opacity, W, H, baseY) {
+//   let dx = 0, dy = 0, off = 30;
+//   if (dir === 'back') dy = off;
+//   if (dir === 'front') dy = -off;
+//   if (dir === 'left') dx = -off;
+//   if (dir === 'right') dx = off;
+
+//   ctx.save();
+//   ctx.fillStyle = `rgba(0,0,0,${opacity})`;
+//   ctx.filter = `blur(${blur}px)`;
+//   ctx.fillRect((W - w) / 2 + dx, baseY - h + dy, w, h);
+//   ctx.restore();
+// }
+
+// function drawCastShadow(ctx, img, w, h, blur, opacity, W, H, baseY, lightX, lightY, dir) {
+//   const shadowCanvas = createCanvas(w, h);
+//   const sctx = shadowCanvas.getContext('2d');
+//   sctx.drawImage(img, 0, 0, w, h);
+//   sctx.globalCompositeOperation = "source-in";
+//   sctx.fillStyle = "black";
+//   sctx.fillRect(0, 0, w, h);
+
+//   // Light/skew calculations
+//   const relX = lightX ? (lightX / W - 0.5) * 2 : (dir === 'left' ? -1 : dir === 'right' ? 1 : 0);
+//   const relY = lightY ? (lightY / H) : (dir === 'front' ? 0.2 : dir === 'back' ? 0.8 : 0.5);
+
+//   const skew = relX * 0.8;
+//   const stretch = 1 + (1 - relY) * 2;
+
+//   ctx.save();
+//   ctx.translate(W / 2, baseY);
+
+//   if (dir === 'front' || relY < 0.5) {
+//     // Front-cast shadow anchored to bottom edge
+//     ctx.transform(1, 0, skew, -0.5, 0, 0); // negative Y stretch
+//     ctx.globalAlpha = opacity;
+//     ctx.filter = `blur(${blur}px)`;
+//     ctx.drawImage(shadowCanvas, -w / 2, -h, w, h); // <- use -h to anchor correctly
+//   } else {
+//     // Shadow behind
+//     ctx.transform(1, 0, skew, 0.3, 0, 0);
+//     ctx.globalAlpha = opacity;
+//     ctx.filter = `blur(${blur}px)`;
+//     ctx.drawImage(shadowCanvas, -w / 2, -h, w, h);
+//   }
+
+//   ctx.restore();
+// }
+
+// // ----------------- Trimming ------------------
+
+// function trimImage(image) {
+//   const temp = createCanvas(image.width, image.height);
+//   const tctx = temp.getContext('2d');
+//   tctx.drawImage(image, 0, 0);
+//   const imgData = tctx.getImageData(0, 0, temp.width, temp.height);
+
+//   let top = temp.height, left = temp.width, right = 0, bottom = 0;
+//   for (let y = 0; y < temp.height; y++) {
+//     for (let x = 0; x < temp.width; x++) {
+//       const alpha = imgData.data[(y * temp.width + x) * 4 + 3];
+//       if (alpha > 0) {
+//         if (x < left) left = x;
+//         if (x > right) right = x;
+//         if (y < top) top = y;
+//         if (y > bottom) bottom = y;
+//       }
+//     }
+//   }
+
+//   const w = right - left + 1;
+//   const h = bottom - top + 1;
+//   const trimmedCanvas = createCanvas(w, h);
+//   const t2 = trimmedCanvas.getContext('2d');
+//   t2.drawImage(image, left, top, w, h, 0, 0, w, h);
+
+//   return { canvas: trimmedCanvas, width: w, height: h };
+// }
+
+// module.exports = { generateShadow };
+
+
+
+// const { createCanvas, loadImage } = require('canvas');
+
+// async function generateShadow(imageBuffer, options = {}) {
+//     const {
+//         type = 'cast',    // cast | drop | flat | box
+//         dir = 'back',     // back | front | left | right
+//         blur = 8,
+//         opacity = 0.35,
+//         lightX,           // optional custom light position
+//         lightY
+//     } = options;
+
+//     const img = await loadImage(imageBuffer);
+//     const trimmed = trimImage(img);
+
+//     const W = 1000, H = 800;  // base canvas size
+//     const canvas = createCanvas(W, H);
+//     const ctx = canvas.getContext('2d');
+
+//     ctx.clearRect(0, 0, W, H); // transparent background
+
+//     // Scale object to fit canvas
+//     const maxW = W * 0.5;
+//     const maxH = H * 0.5;
+//     const scale = Math.min(maxW / trimmed.width, maxH / trimmed.height, 1);
+//     const scaledW = trimmed.width * scale;
+//     const scaledH = trimmed.height * scale;
+//     const baseY = H * 0.85;
+
+//     // Draw shadow
+//     switch (type) {
+//         case 'drop':
+//             drawDropShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, blur, opacity, W, H, baseY);
+//             break;
+//         case 'flat':
+//             drawFlatShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, opacity, W, H, baseY);
+//             break;
+//         case 'box':
+//             drawBoxShadow(ctx, scaledW, scaledH, dir, blur, opacity, W, H, baseY);
+//             break;
+//         case 'cast':
+//         default:
+//             drawCastShadow(ctx, trimmed.canvas, scaledW, scaledH, blur, opacity, W, H, baseY, lightX, lightY, dir);
+//             break;
+//     }
+
+//     // Draw object on top
+//     ctx.globalAlpha = 1;
+//     ctx.filter = "none";
+//     ctx.drawImage(trimmed.canvas, (W - scaledW) / 2, baseY - scaledH, scaledW, scaledH);
+
+//     return canvas.toBuffer("image/png");
+// }
+
+// // ----------------- Shadow Types ------------------
+
+// function drawDropShadow(ctx, img, w, h, dir, blur, opacity, W, H, baseY) {
+//     let dx = 0, dy = 0, off = 40;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     ctx.save();
+//     ctx.filter = `blur(${blur}px)`;
+//     ctx.globalAlpha = opacity;
+//     ctx.drawImage(img, (W - w) / 2 + dx, baseY - h + dy, w, h);
+//     ctx.restore();
+// }
+
+// function drawFlatShadow(ctx, img, w, h, dir, opacity, W, H, baseY) {
+//     let dx = 0, dy = 0, off = 30;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     ctx.save();
+//     ctx.globalAlpha = opacity;
+//     ctx.drawImage(img, (W - w) / 2 + dx, baseY - h + dy, w, h);
+//     ctx.restore();
+// }
+
+// function drawBoxShadow(ctx, w, h, dir, blur, opacity, W, H, baseY) {
+//     let dx = 0, dy = 0, off = 30;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     ctx.save();
+//     ctx.fillStyle = `rgba(0,0,0,${opacity})`;
+//     ctx.filter = `blur(${blur}px)`;
+//     ctx.fillRect((W - w) / 2 + dx, baseY - h + dy, w, h);
+//     ctx.restore();
+// }
+
+// function drawCastShadow(ctx, img, w, h, blur, opacity, W, H, baseY, lightX, lightY, dir) {
+//     const shadowCanvas = createCanvas(w, h);
+//     const sctx = shadowCanvas.getContext('2d');
+
+//     // Draw object into shadow canvas
+//     sctx.drawImage(img, 0, 0, w, h);
+//     sctx.globalCompositeOperation = "source-in";
+//     sctx.fillStyle = "black";
+//     sctx.fillRect(0, 0, w, h);
+
+//     const relX = lightX ? (lightX / W - 0.5) * 2 : (dir === 'left' ? -1 : dir === 'right' ? 1 : 0);
+//     const relY = lightY ? (lightY / H) : (dir === 'front' ? 0.2 : dir === 'back' ? 0.8 : 0.5);
+
+//     const skew = relX * 0.8;
+
+//     ctx.save();
+//     ctx.translate(W / 2, baseY);
+
+//     if (dir === 'front' || relY < 0.5) {
+//         ctx.transform(1, 0, skew, -0.5, 0, 0);
+//         ctx.globalAlpha = opacity;
+//         ctx.filter = `blur(${blur}px)`;
+//         ctx.drawImage(shadowCanvas, -w / 2, -h, w, h); // anchored to bottom edge
+//     } else {
+//         ctx.transform(1, 0, skew, 0.3, 0, 0);
+//         ctx.globalAlpha = opacity;
+//         ctx.filter = `blur(${blur}px)`;
+//         ctx.drawImage(shadowCanvas, -w / 2, -h, w, h);
+//     }
+
+//     ctx.restore();
+// }
+
+// // ----------------- Trimming ------------------
+
+// function trimImage(image) {
+//     const temp = createCanvas(image.width, image.height);
+//     const tctx = temp.getContext('2d');
+//     tctx.drawImage(image, 0, 0);
+//     const imgData = tctx.getImageData(0, 0, temp.width, temp.height);
+
+//     let top = temp.height, left = temp.width, right = 0, bottom = 0;
+//     for (let y = 0; y < temp.height; y++) {
+//         for (let x = 0; x < temp.width; x++) {
+//             const alpha = imgData.data[(y * temp.width + x) * 4 + 3];
+//             if (alpha > 0) {
+//                 if (x < left) left = x;
+//                 if (x > right) right = x;
+//                 if (y < top) top = y;
+//                 if (y > bottom) bottom = y;
+//             }
+//         }
+//     }
+
+//     const w = right - left + 1;
+//     const h = bottom - top + 1;
+//     const trimmedCanvas = createCanvas(w, h);
+//     const t2 = trimmedCanvas.getContext('2d');
+//     t2.drawImage(image, left, top, w, h, 0, 0, w, h);
+
+//     return { canvas: trimmedCanvas, width: w, height: h };
+// }
+
+// module.exports = { generateShadow };
+
+
+
+
+// const { createCanvas, loadImage } = require('canvas');
+// const fs = require('fs'); // <-- add this
+
+// async function generateShadow(imageBuffer, options = {}) {
+//     const {
+//         type = 'cast',    // cast | drop | flat | box
+//         dir = 'back',     // back | front | left | right
+//         blur = 8,
+//         opacity = 0.35,
+//         lightX,
+//         lightY
+//     } = options;
+
+//     const img = await loadImage(imageBuffer);
+//     const trimmed = trimImage(img);
+
+//     // ---------------- Scale object ----------------
+//     const W = 1000, H = 800;
+//     const maxW = W * 0.5;
+//     const maxH = H * 0.5;
+//     const scale = Math.min(maxW / trimmed.width, maxH / trimmed.height, 1);
+//     const scaledW = trimmed.width * scale;
+//     const scaledH = trimmed.height * scale;
+
+//     // ---------------- Shadow offset padding ----------------
+//     const shadowOffset = type === 'drop' ? 50 : type === 'flat' ? 40 : type === 'box' ? 40 : 200;
+//     let extraTop = 0, extraBottom = 0, extraLeft = 0, extraRight = 0;
+
+//     if (dir === 'back') extraBottom = shadowOffset;
+//     if (dir === 'front') extraTop = shadowOffset;
+//     if (dir === 'left') extraLeft = shadowOffset;
+//     if (dir === 'right') extraRight = shadowOffset;
+
+//     const canvasW = W + extraLeft + extraRight;
+//     const canvasH = H + extraTop + extraBottom;
+//     const canvas = createCanvas(canvasW, canvasH);
+//     const ctx = canvas.getContext('2d');
+//     ctx.clearRect(0, 0, canvasW, canvasH);
+
+//     const baseX = extraLeft + (canvasW - extraLeft - extraRight) / 2;
+//     const baseY = extraTop + H * 0.85;
+
+//     // ---------------- Draw shadow ----------------
+//     switch (type) {
+//         case 'drop':
+//             drawDropShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, blur, opacity, canvasW, canvasH, baseX, baseY);
+//             break;
+//         case 'flat':
+//             drawFlatShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, opacity, canvasW, canvasH, baseX, baseY);
+//             break;
+//         case 'box':
+//             drawBoxShadow(ctx, scaledW, scaledH, dir, blur, opacity, canvasW, canvasH, baseX, baseY);
+//             break;
+//         case 'cast':
+//         default:
+//             drawCastShadow(ctx, trimmed.canvas, scaledW, scaledH, blur, opacity, canvasW, canvasH, baseX, baseY, lightX, lightY, dir);
+//             break;
+//     }
+
+//     // ---------------- Draw object ----------------
+//     ctx.globalAlpha = 1;
+//     ctx.filter = "none";
+//     ctx.drawImage(trimmed.canvas, baseX - scaledW / 2, baseY - scaledH, scaledW, scaledH);
+
+//     // ---------------- Debug: save image ----------------
+//     fs.writeFileSync('debug_shadow.png', canvas.toBuffer("image/png"));
+
+//     return canvas.toBuffer("image/png");
+// }
+
+// // ---------------- Shadow functions ----------------
+
+// function drawDropShadow(ctx, img, w, h, dir, blur, opacity, W, H, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 40;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     ctx.save();
+//     ctx.filter = `blur(${blur}px)`;
+//     ctx.globalAlpha = opacity;
+//     ctx.drawImage(img, baseX - w / 2 + dx, baseY - h + dy, w, h);
+//     ctx.restore();
+// }
+
+// function drawFlatShadow(ctx, img, w, h, dir, opacity, W, H, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 30;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     ctx.save();
+//     ctx.globalAlpha = opacity;
+//     ctx.drawImage(img, baseX - w / 2 + dx, baseY - h + dy, w, h);
+//     ctx.restore();
+// }
+
+// function drawBoxShadow(ctx, w, h, dir, blur, opacity, W, H, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 30;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     ctx.save();
+//     ctx.fillStyle = `rgba(0,0,0,${opacity})`;
+//     ctx.filter = `blur(${blur}px)`;
+//     ctx.fillRect(baseX - w / 2 + dx, baseY - h + dy, w, h);
+//     ctx.restore();
+// }
+
+// function drawCastShadow(ctx, img, w, h, blur, opacity, W, H, baseX, baseY, lightX, lightY, dir) {
+//     const shadowCanvas = createCanvas(w, h);
+//     const sctx = shadowCanvas.getContext('2d');
+
+//     sctx.drawImage(img, 0, 0, w, h);
+//     sctx.globalCompositeOperation = "source-in";
+//     sctx.fillStyle = "black";
+//     sctx.fillRect(0, 0, w, h);
+
+//     const relX = lightX ? (lightX / W - 0.5) * 2 : (dir === 'left' ? -1 : dir === 'right' ? 1 : 0);
+//     const relY = lightY ? (lightY / H) : (dir === 'front' ? 0.2 : dir === 'back' ? 0.8 : 0.5);
+
+//     const skew = relX * 0.8;
+
+//     ctx.save();
+//     ctx.translate(baseX, baseY);
+
+//     if (dir === 'front' || relY < 0.5) {
+//         ctx.transform(1, 0, skew, -0.5, 0, 0);
+//         ctx.globalAlpha = opacity;
+//         ctx.filter = `blur(${blur}px)`;
+//         ctx.drawImage(shadowCanvas, -w / 2, -h, w, h);
+//     } else {
+//         ctx.transform(1, 0, skew, 0.3, 0, 0);
+//         ctx.globalAlpha = opacity;
+//         ctx.filter = `blur(${blur}px)`;
+//         ctx.drawImage(shadowCanvas, -w / 2, -h, w, h);
+//     }
+
+//     ctx.restore();
+// }
+
+// // ---------------- Trimming ----------------
+// function trimImage(image) {
+//     const temp = createCanvas(image.width, image.height);
+//     const tctx = temp.getContext('2d');
+//     tctx.drawImage(image, 0, 0);
+//     const imgData = tctx.getImageData(0, 0, temp.width, temp.height);
+
+//     let top = temp.height, left = temp.width, right = 0, bottom = 0;
+//     for (let y = 0; y < temp.height; y++) {
+//         for (let x = 0; x < temp.width; x++) {
+//             const alpha = imgData.data[(y * temp.width + x) * 4 + 3];
+//             if (alpha > 0) {
+//                 if (x < left) left = x;
+//                 if (x > right) right = x;
+//                 if (y < top) top = y;
+//                 if (y > bottom) bottom = y;
+//             }
+//         }
+//     }
+
+//     const w = right - left + 1;
+//     const h = bottom - top + 1;
+//     const trimmedCanvas = createCanvas(w, h);
+//     const t2 = trimmedCanvas.getContext('2d');
+//     t2.drawImage(image, left, top, w, h, 0, 0, w, h);
+
+//     return { canvas: trimmedCanvas, width: w, height: h };
+// }
+
+// module.exports = { generateShadow };
+
+
+
+
+// const { createCanvas, loadImage } = require('canvas');
+// const fs = require('fs'); 
+
+// async function generateShadow(imageBuffer, options = {}) {
+//     const {
+//         type = 'cast',    // cast | drop | flat | box
+//         dir = 'back',     // back | front | left | right
+//         blur = 8,
+//         opacity = 0.35,
+//         lightX,
+//         lightY
+//     } = options;
+
+//     const img = await loadImage(imageBuffer);
+//     const trimmed = trimImage(img);
+
+//     // ---------------- Scale object ----------------
+//     const W = 1000, H = 800;
+//     const maxW = W * 0.5;
+//     const maxH = H * 0.5;
+//     const scale = Math.min(maxW / trimmed.width, maxH / trimmed.height, 1);
+//     const scaledW = trimmed.width * scale;
+//     const scaledH = trimmed.height * scale;
+
+//     // ---------------- Shadow offset padding ----------------
+//     const shadowOffset = type === 'drop' ? 50 : type === 'flat' ? 40 : type === 'box' ? 40 : 200;
+//     let extraTop = 0, extraBottom = 0, extraLeft = 0, extraRight = 0;
+
+//     if (dir === 'back') extraBottom = shadowOffset;
+//     if (dir === 'front') extraTop = shadowOffset;
+//     if (dir === 'left') extraLeft = shadowOffset;
+//     if (dir === 'right') extraRight = shadowOffset;
+
+//     // Extra padding for cast shadows to prevent clipping
+//     if (type === 'cast') {
+//         extraTop += scaledH * 0.5;
+//         extraBottom += scaledH * 0.5;
+//         extraLeft += scaledW * 0.3;
+//         extraRight += scaledW * 0.3;
+//     }
+
+//     const canvasW = W + extraLeft + extraRight;
+//     const canvasH = H + extraTop + extraBottom;
+//     const canvas = createCanvas(canvasW, canvasH);
+//     const ctx = canvas.getContext('2d');
+//     ctx.clearRect(0, 0, canvasW, canvasH);
+
+//     // ---------------- Base position ----------------
+//     const baseX = extraLeft + W / 2;
+//     const baseY = extraTop + H; // bottom of object
+
+//     // ---------------- Draw shadow ----------------
+//     switch (type) {
+//         case 'drop':
+//             drawDropShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, blur, opacity, canvasW, canvasH, baseX, baseY);
+//             break;
+//         case 'flat':
+//             drawFlatShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, opacity, canvasW, canvasH, baseX, baseY);
+//             break;
+//         case 'box':
+//             drawBoxShadow(ctx, scaledW, scaledH, dir, blur, opacity, canvasW, canvasH, baseX, baseY);
+//             break;
+//         case 'cast':
+//         default:
+//             drawCastShadow(ctx, trimmed.canvas, scaledW, scaledH, blur, opacity, canvasW, canvasH, baseX, baseY, lightX, lightY, dir);
+//             break;
+//     }
+
+//     // ---------------- Draw object ----------------
+//     ctx.globalAlpha = 1;
+//     ctx.filter = "none";
+//     ctx.drawImage(trimmed.canvas, baseX - scaledW / 2, baseY - scaledH, scaledW, scaledH);
+
+//     // ---------------- Debug: save image ----------------
+//     fs.writeFileSync('debug_shadow.png', canvas.toBuffer("image/png"));
+
+//     return canvas.toBuffer("image/png");
+// }
+
+// // ---------------- Shadow functions ----------------
+
+// function drawDropShadow(ctx, img, w, h, dir, blur, opacity, W, H, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 40;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     ctx.save();
+//     ctx.filter = `blur(${blur}px)`;
+//     ctx.globalAlpha = opacity;
+//     ctx.drawImage(img, baseX - w / 2 + dx, baseY - h + dy, w, h);
+//     ctx.restore();
+// }
+
+// function drawFlatShadow(ctx, img, w, h, dir, opacity, W, H, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 30;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     ctx.save();
+//     ctx.globalAlpha = opacity;
+//     ctx.drawImage(img, baseX - w / 2 + dx, baseY - h + dy, w, h);
+//     ctx.restore();
+// }
+
+// function drawBoxShadow(ctx, w, h, dir, blur, opacity, W, H, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 30;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     ctx.save();
+//     ctx.fillStyle = `rgba(0,0,0,${opacity})`;
+//     ctx.filter = `blur(${blur}px)`;
+//     ctx.fillRect(baseX - w / 2 + dx, baseY - h + dy, w, h);
+//     ctx.restore();
+// }
+
+// function drawCastShadow(ctx, img, w, h, blur, opacity, W, H, baseX, baseY, lightX, lightY, dir) {
+//     const shadowCanvas = createCanvas(w, h);
+//     const sctx = shadowCanvas.getContext('2d');
+
+//     sctx.drawImage(img, 0, 0, w, h);
+//     sctx.globalCompositeOperation = "source-in";
+//     sctx.fillStyle = "black";
+//     sctx.fillRect(0, 0, w, h);
+
+//     const relX = lightX ? (lightX / W - 0.5) * 2 : (dir === 'left' ? -1 : dir === 'right' ? 1 : 0);
+//     const relY = lightY ? (lightY / H) : (dir === 'front' ? 0.2 : dir === 'back' ? 0.8 : 0.5);
+
+//     const skew = relX * 0.8;
+
+//     ctx.save();
+//     ctx.translate(baseX, baseY);
+
+//     if (dir === 'front' || relY < 0.5) {
+//         ctx.transform(1, 0, skew, -0.5, 0, 0);
+//     } else {
+//         ctx.transform(1, 0, skew, 0.3, 0, 0);
+//     }
+//     ctx.globalAlpha = opacity;
+//     ctx.filter = `blur(${blur}px)`;
+//     ctx.drawImage(shadowCanvas, -w / 2, -h, w, h);
+
+//     ctx.restore();
+// }
+
+// // ---------------- Trimming ----------------
+// function trimImage(image) {
+//     const temp = createCanvas(image.width, image.height);
+//     const tctx = temp.getContext('2d');
+//     tctx.drawImage(image, 0, 0);
+//     const imgData = tctx.getImageData(0, 0, temp.width, temp.height);
+
+//     let top = temp.height, left = temp.width, right = 0, bottom = 0;
+//     for (let y = 0; y < temp.height; y++) {
+//         for (let x = 0; x < temp.width; x++) {
+//             const alpha = imgData.data[(y * temp.width + x) * 4 + 3];
+//             if (alpha > 0) {
+//                 if (x < left) left = x;
+//                 if (x > right) right = x;
+//                 if (y < top) top = y;
+//                 if (y > bottom) bottom = y;
+//             }
+//         }
+//     }
+
+//     const w = right - left + 1;
+//     const h = bottom - top + 1;
+//     const trimmedCanvas = createCanvas(w, h);
+//     const t2 = trimmedCanvas.getContext('2d');
+//     t2.drawImage(image, left, top, w, h, 0, 0, w, h);
+
+//     return { canvas: trimmedCanvas, width: w, height: h };
+// }
+
+// module.exports = { generateShadow };
+
+
+// const { createCanvas, loadImage } = require('canvas');
+// const fs = require('fs');
+// const StackBlur = require('stackblur-canvas'); // Node-compatible
+
+// async function generateShadow(imageBuffer, options = {}) {
+//     const {
+//         type = 'cast',    // cast | drop | flat | box
+//         dir = 'back',     // back | front | left | right
+//         blur = 20,        // px
+//         opacity = 0.35,
+//         lightX,
+//         lightY
+//     } = options;
+
+//     const img = await loadImage(imageBuffer);
+//     const trimmed = trimImage(img); // <-- precise trimming
+
+//     // ---------------- Scale object ----------------
+//     const W = 1000, H = 800;
+//     const maxW = W * 0.5;
+//     const maxH = H * 0.5;
+//     const scale = Math.min(maxW / trimmed.width, maxH / trimmed.height, 1);
+//     const scaledW = trimmed.width * scale;
+//     const scaledH = trimmed.height * scale;
+
+//     // ---------------- Shadow padding ----------------
+//     let shadowOffset = type === 'drop' ? 50 : type === 'flat' ? 40 : type === 'box' ? 40 : 200;
+//     let extraTop = 0, extraBottom = 0, extraLeft = 0, extraRight = 0;
+
+//     if (dir === 'back') extraBottom = shadowOffset;
+//     if (dir === 'front') extraTop = shadowOffset;
+//     if (dir === 'left') extraLeft = shadowOffset;
+//     if (dir === 'right') extraRight = shadowOffset;
+
+//     if (type === 'cast') {
+//         extraTop += scaledH * 0.5;
+//         extraBottom += scaledH * 0.5;
+//         extraLeft += scaledW * 0.3;
+//         extraRight += scaledW * 0.3;
+//     }
+
+//     const canvasW = W + extraLeft + extraRight;
+//     const canvasH = H + extraTop + extraBottom;
+//     const canvas = createCanvas(canvasW, canvasH);
+//     const ctx = canvas.getContext('2d');
+//     ctx.clearRect(0, 0, canvasW, canvasH);
+
+//     // ---------------- Base position ----------------
+//     const baseX = extraLeft + W / 2;
+//     const baseY = extraTop + H; // bottom of object
+
+//     // ---------------- Draw shadow ----------------
+//     switch (type) {
+//         case 'drop':
+//             drawDropShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, blur, opacity, baseX, baseY);
+//             break;
+//         case 'flat':
+//             drawFlatShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, opacity, baseX, baseY);
+//             break;
+//         case 'box':
+//             drawBoxShadow(ctx, scaledW, scaledH, dir, blur, opacity, baseX, baseY);
+//             break;
+//         case 'cast':
+//         default:
+//             drawCastShadow(ctx, trimmed.canvas, scaledW, scaledH, blur, opacity, baseX, baseY, lightX, lightY, dir);
+//             break;
+//     }
+
+//     // ---------------- Draw object ----------------
+//     ctx.globalAlpha = 1;
+//     ctx.filter = "none";
+//     ctx.drawImage(trimmed.canvas, baseX - scaledW / 2, baseY - scaledH, scaledW, scaledH);
+
+//     // ---------------- Debug save ----------------
+//     fs.writeFileSync('debug_shadow.png', canvas.toBuffer("image/png"));
+
+//     return canvas.toBuffer("image/png");
+// }
+
+// // ---------------- Shadow helpers ----------------
+
+// // Compute padding (based on blur) and overlap so blurred shadow touches the image.
+// function computePadOverlap(blur) {
+//     const pad = Math.max(4, Math.ceil(blur * 2)); // ensures enough padding for blur spread
+//     const overlap = Math.max(1, Math.round(blur * 0.6)); // how many px the shadow will overlap the image edge
+//     return { pad, overlap };
+// }
+
+// function drawDropShadow(ctx, img, w, h, dir, blur, opacity, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 40;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     const { pad, overlap } = computePadOverlap(blur);
+
+//     // Create shadow canvas with padding so blur doesn't get clipped
+//     const shadowCanvas = createCanvas(Math.round(w + pad), Math.round(h + pad));
+//     const sctx = shadowCanvas.getContext('2d');
+
+//     const drawX = pad / 2;
+//     const drawY = pad / 2;
+//     sctx.clearRect(0, 0, shadowCanvas.width, shadowCanvas.height);
+//     sctx.drawImage(img, drawX, drawY, w, h);
+//     sctx.globalCompositeOperation = "source-in";
+//     sctx.fillStyle = "black";
+//     sctx.fillRect(0, 0, shadowCanvas.width, shadowCanvas.height);
+
+//     StackBlur.canvasRGBA(shadowCanvas, 0, 0, shadowCanvas.width, shadowCanvas.height, blur);
+
+//     ctx.save();
+//     ctx.globalAlpha = opacity;
+//     // When drawing, position so the padded canvas overlaps the object's bottom by `overlap`
+//     const drawPosX = baseX - w / 2 + dx - pad / 2;
+//     const drawPosY = baseY - h + dy - pad / 2 + overlap;
+//     ctx.drawImage(shadowCanvas, drawPosX, drawPosY, shadowCanvas.width, shadowCanvas.height);
+//     ctx.restore();
+// }
+
+// function drawFlatShadow(ctx, img, w, h, dir, opacity, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 30;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     ctx.save();
+//     ctx.globalAlpha = opacity;
+//     // flat shadow should sit directly under, so small upward overlap to avoid gap
+//     ctx.drawImage(img, baseX - w/2 + dx, baseY - h + dy + 1, w, h);
+//     ctx.restore();
+// }
+
+// function drawBoxShadow(ctx, w, h, dir, blur, opacity, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 30;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     const { pad, overlap } = computePadOverlap(blur);
+
+//     const shadowCanvas = createCanvas(Math.round(w + pad), Math.round(h + pad));
+//     const sctx = shadowCanvas.getContext('2d');
+//     sctx.clearRect(0, 0, shadowCanvas.width, shadowCanvas.height);
+
+//     // draw a filled rectangle centered with padding
+//     sctx.fillStyle = `black`;
+//     sctx.fillRect(pad/2, pad/2, w, h);
+
+//     StackBlur.canvasRGBA(shadowCanvas, 0, 0, shadowCanvas.width, shadowCanvas.height, blur);
+
+//     ctx.save();
+//     ctx.globalAlpha = opacity;
+//     const drawPosX = baseX - w/2 + dx - pad / 2;
+//     const drawPosY = baseY - h + dy - pad / 2 + overlap;
+//     ctx.drawImage(shadowCanvas, drawPosX, drawPosY, shadowCanvas.width, shadowCanvas.height);
+//     ctx.restore();
+// }
+
+// function drawCastShadow(ctx, img, w, h, blur, opacity, baseX, baseY, lightX, lightY, dir) {
+//     // We'll pad by blur*2 so StackBlur has room, then draw the original at pad/2,pad/2
+//     const { pad, overlap } = computePadOverlap(blur);
+//     const shadowW = Math.round(w + pad);
+//     const shadowH = Math.round(h + pad);
+//     const shadowCanvas = createCanvas(shadowW, shadowH);
+//     const sctx = shadowCanvas.getContext('2d');
+
+//     sctx.clearRect(0, 0, shadowW, shadowH);
+//     const drawX = pad / 2;
+//     const drawY = pad / 2;
+//     sctx.drawImage(img, drawX, drawY, w, h);
+//     sctx.globalCompositeOperation = "source-in";
+//     sctx.fillStyle = "black";
+//     sctx.fillRect(0, 0, shadowW, shadowH);
+
+//     // Apply exact StackBlur (unchanged logic)
+//     StackBlur.canvasRGBA(shadowCanvas, 0, 0, shadowW, shadowH, blur);
+
+//     // Compute relative light/ skew similar to your original logic but keep consistent units
+//     // Use the canvas display size W/H approximation from wrapper (we don't have W,H here) so interpret rels relative to w/h:
+//     const relX = lightX ? (lightX / (w * 2) - 0.5) * 2 : (dir === 'left' ? -1 : dir === 'right' ? 1 : 0);
+//     const relY = lightY ? (lightY / (h * 2)) : (dir === 'front' ? 0.2 : dir === 'back' ? 0.8 : 0.5);
+//     const skew = relX * 0.8;
+
+//     ctx.save();
+//     ctx.translate(baseX, baseY);
+
+//     if (dir === 'front' || relY < 0.5) ctx.transform(1, 0, skew, -0.5, 0, 0);
+//     else ctx.transform(1, 0, skew, 0.3, 0, 0);
+
+//     ctx.globalAlpha = opacity;
+
+//     // Draw shadowCanvas so its inner image area overlaps the object's bottom by `overlap`
+//     // The object's top-left in local coords is (-w/2, -h)
+//     // Our padded image top-left is (-w/2 - pad/2, -h - pad/2)
+//     const drawPosX = -w / 2 - pad / 2;
+//     const drawPosY = -h - pad / 2 + overlap; // +overlap moves the shadow slightly up so blur touches object
+//     ctx.drawImage(shadowCanvas, drawPosX, drawPosY, shadowW, shadowH);
+
+//     ctx.restore();
+// }
+
+// // ---------------- Trimming ----------------
+// function trimImage(image) {
+//     const temp = createCanvas(image.width, image.height);
+//     const tctx = temp.getContext('2d');
+//     tctx.drawImage(image, 0, 0);
+//     const imgData = tctx.getImageData(0, 0, temp.width, temp.height);
+
+//     let top = temp.height, left = temp.width, right = 0, bottom = 0;
+//     for (let y = 0; y < temp.height; y++) {
+//         for (let x = 0; x < temp.width; x++) {
+//             const alpha = imgData.data[(y * temp.width + x) * 4 + 3];
+//             if (alpha > 0) {
+//                 if (x < left) left = x;
+//                 if (x > right) right = x;
+//                 if (y < top) top = y;
+//                 if (y > bottom) bottom = y;
+//             }
+//         }
+//     }
+
+//     const w = right - left + 1;
+//     const h = bottom - top + 1;
+//     const trimmedCanvas = createCanvas(w, h);
+//     const t2 = trimmedCanvas.getContext('2d');
+//     t2.drawImage(image, left, top, w, h, 0, 0, w, h);
+
+//     return { canvas: trimmedCanvas, width: w, height: h };
+// }
+
+// module.exports = { generateShadow };
+
+
+// const { createCanvas, loadImage } = require('canvas');
+// const fs = require('fs');
+// const StackBlur = require('stackblur-canvas'); // Node-compatible
+
+// async function generateShadow(imageBuffer, options = {}) {
+//     const {
+//         type = 'cast',    // cast | drop | flat | box
+//         dir = 'back',     // back | front | left | right
+//         blur = 20,        // px
+//         opacity = 0.35,
+//         lightX,
+//         lightY
+//     } = options;
+
+//     const img = await loadImage(imageBuffer);
+//     const trimmed = trimImage(img); // precise trimming
+
+//     // ---------------- Scale object ----------------
+//     const W = 1000, H = 800;
+//     const maxW = W * 0.5;
+//     const maxH = H * 0.5;
+//     const scale = Math.min(maxW / trimmed.width, maxH / trimmed.height, 1);
+//     const scaledW = trimmed.width * scale;
+//     const scaledH = trimmed.height * scale;
+
+//     // ---------------- Shadow padding ----------------
+//     let shadowOffset = type === 'drop' ? 50 : type === 'flat' ? 40 : type === 'box' ? 40 : 200;
+//     let extraTop = 0, extraBottom = 0, extraLeft = 0, extraRight = 0;
+
+//     if (dir === 'back') {
+//         extraBottom = shadowOffset;
+//         // left/right padding applied only for back direction
+//         extraLeft = shadowOffset;
+//         extraRight = shadowOffset;
+//     } 
+//     if (dir === 'front') extraTop = shadowOffset;
+
+//     if (type === 'cast') {
+//         extraTop += scaledH * 0.5;
+//         extraBottom += scaledH * 0.5;
+//         if (dir === 'back') {
+//             extraLeft += scaledW * 0.3;
+//             extraRight += scaledW * 0.3;
+//         }
+//     }
+
+//     const canvasW = W + extraLeft + extraRight;
+//     const canvasH = H + extraTop + extraBottom;
+//     const canvas = createCanvas(canvasW, canvasH);
+//     const ctx = canvas.getContext('2d');
+//     ctx.clearRect(0, 0, canvasW, canvasH);
+
+//     // ---------------- Base position ----------------
+//     const baseX = extraLeft + W / 2;
+//     const baseY = extraTop + H; // bottom of object
+
+//     // ---------------- Draw shadow ----------------
+//     switch (type) {
+//         case 'drop':
+//             drawDropShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, blur, opacity, baseX, baseY);
+//             break;
+//         case 'flat':
+//             drawFlatShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, opacity, baseX, baseY);
+//             break;
+//         case 'box':
+//             drawBoxShadow(ctx, scaledW, scaledH, dir, blur, opacity, baseX, baseY);
+//             break;
+//         case 'cast':
+//         default:
+//             drawCastShadow(ctx, trimmed.canvas, scaledW, scaledH, blur, opacity, baseX, baseY, lightX, lightY, dir);
+//             break;
+//     }
+
+//     // ---------------- Draw object ----------------
+//     ctx.globalAlpha = 1;
+//     ctx.filter = "none";
+//     ctx.drawImage(trimmed.canvas, baseX - scaledW / 2, baseY - scaledH, scaledW, scaledH);
+
+//     // ---------------- Debug save ----------------
+
+//     return canvas.toBuffer("image/png");
+// }
+
+// // ---------------- Shadow helpers ----------------
+// function computePadOverlap(blur) {
+//     const pad = Math.max(4, Math.ceil(blur * 2)); // ensures enough padding for blur spread
+//     const overlap = Math.max(1, Math.round(blur * 0.6)); // shadow overlap with object
+//     return { pad, overlap };
+// }
+
+// function drawDropShadow(ctx, img, w, h, dir, blur, opacity, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 40;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     const { pad, overlap } = computePadOverlap(blur);
+
+//     const shadowCanvas = createCanvas(Math.round(w + pad), Math.round(h + pad));
+//     const sctx = shadowCanvas.getContext('2d');
+
+//     const drawX = pad / 2;
+//     const drawY = pad / 2;
+//     sctx.clearRect(0, 0, shadowCanvas.width, shadowCanvas.height);
+//     sctx.drawImage(img, drawX, drawY, w, h);
+//     sctx.globalCompositeOperation = "source-in";
+//     sctx.fillStyle = "black";
+//     sctx.fillRect(0, 0, shadowCanvas.width, shadowCanvas.height);
+
+//     StackBlur.canvasRGBA(shadowCanvas, 0, 0, shadowCanvas.width, shadowCanvas.height, blur);
+
+//     ctx.save();
+//     ctx.globalAlpha = opacity;
+//     const drawPosX = baseX - w / 2 + dx - pad / 2;
+//     const drawPosY = baseY - h + dy - pad / 2 + overlap;
+//     ctx.drawImage(shadowCanvas, drawPosX, drawPosY, shadowCanvas.width, shadowCanvas.height);
+//     ctx.restore();
+// }
+
+// function drawFlatShadow(ctx, img, w, h, dir, opacity, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 30;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     ctx.save();
+//     ctx.globalAlpha = opacity;
+//     ctx.drawImage(img, baseX - w/2 + dx, baseY - h + dy + 1, w, h);
+//     ctx.restore();
+// }
+
+// function drawBoxShadow(ctx, w, h, dir, blur, opacity, baseX, baseY) {
+//     let dx = 0, dy = 0, off = 30;
+//     if (dir === 'back') dy = off;
+//     if (dir === 'front') dy = -off;
+//     if (dir === 'left') dx = -off;
+//     if (dir === 'right') dx = off;
+
+//     const { pad, overlap } = computePadOverlap(blur);
+
+//     const shadowCanvas = createCanvas(Math.round(w + pad), Math.round(h + pad));
+//     const sctx = shadowCanvas.getContext('2d');
+//     sctx.clearRect(0, 0, shadowCanvas.width, shadowCanvas.height);
+
+//     sctx.fillStyle = `black`;
+//     sctx.fillRect(pad/2, pad/2, w, h);
+
+//     StackBlur.canvasRGBA(shadowCanvas, 0, 0, shadowCanvas.width, shadowCanvas.height, blur);
+
+//     ctx.save();
+//     ctx.globalAlpha = opacity;
+//     const drawPosX = baseX - w/2 + dx - pad / 2;
+//     const drawPosY = baseY - h + dy - pad / 2 + overlap;
+//     ctx.drawImage(shadowCanvas, drawPosX, drawPosY, shadowCanvas.width, shadowCanvas.height);
+//     ctx.restore();
+// }
+
+// function drawCastShadow(ctx, img, w, h, blur, opacity, baseX, baseY, lightX, lightY, dir) {
+//     const { pad, overlap } = computePadOverlap(blur);
+//     const shadowW = Math.round(w + pad);
+//     const shadowH = Math.round(h + pad);
+//     const shadowCanvas = createCanvas(shadowW, shadowH);
+//     const sctx = shadowCanvas.getContext('2d');
+
+//     sctx.clearRect(0, 0, shadowW, shadowH);
+//     const drawX = pad / 2;
+//     const drawY = pad / 2;
+//     sctx.drawImage(img, drawX, drawY, w, h);
+//     sctx.globalCompositeOperation = "source-in";
+//     sctx.fillStyle = "black";
+//     sctx.fillRect(0, 0, shadowW, shadowH);
+
+//     StackBlur.canvasRGBA(shadowCanvas, 0, 0, shadowW, shadowH, blur);
+
+//     const relX = lightX ? (lightX / (w * 2) - 0.5) * 2 : (dir === 'left' ? -1 : dir === 'right' ? 1 : 0);
+//     const relY = lightY ? (lightY / (h * 2)) : (dir === 'front' ? 0.2 : dir === 'back' ? 0.8 : 0.5);
+//     const skew = relX * 0.8;
+
+//     ctx.save();
+//     ctx.translate(baseX, baseY);
+//     if (dir === 'front' || relY < 0.5) ctx.transform(1, 0, skew, -0.5, 0, 0);
+//     else ctx.transform(1, 0, skew, 0.3, 0, 0);
+
+//     ctx.globalAlpha = opacity;
+//     const drawPosX = -w / 2 - pad / 2;
+//     const drawPosY = -h - pad / 2 + overlap;
+//     ctx.drawImage(shadowCanvas, drawPosX, drawPosY, shadowW, shadowH);
+
+//     ctx.restore();
+// }
+
+// // ---------------- Trimming ----------------
+// function trimImage(image) {
+//     const temp = createCanvas(image.width, image.height);
+//     const tctx = temp.getContext('2d');
+//     tctx.drawImage(image, 0, 0);
+//     const imgData = tctx.getImageData(0, 0, temp.width, temp.height);
+
+//     let top = temp.height, left = temp.width, right = 0, bottom = 0;
+//     for (let y = 0; y < temp.height; y++) {
+//         for (let x = 0; x < temp.width; x++) {
+//             const alpha = imgData.data[(y * temp.width + x) * 4 + 3];
+//             if (alpha > 0) {
+//                 if (x < left) left = x;
+//                 if (x > right) right = x;
+//                 if (y < top) top = y;
+//                 if (y > bottom) bottom = y;
+//             }
+//         }
+//     }
+
+//     const w = right - left + 1;
+//     const h = bottom - top + 1;
+//     const trimmedCanvas = createCanvas(w, h);
+//     const t2 = trimmedCanvas.getContext('2d');
+//     t2.drawImage(image, left, top, w, h, 0, 0, w, h);
+
+//     return { canvas: trimmedCanvas, width: w, height: h };
+// }
+
+// module.exports = { generateShadow };
+
+
+
+const { createCanvas, loadImage } = require('canvas');
+const StackBlur = require('stackblur-canvas'); // Node-compatible
+
+async function generateShadow(imageBuffer, options = {}) {
+    const {
+        type = 'cast',    // cast | drop | flat | box
+        dir = 'back',     // back | front | left | right
+        blur = 20,        // px
+        opacity = 0.35,
+        lightX,
+        lightY
+    } = options;
+
+    const img = await loadImage(imageBuffer);
+    const trimmed = trimImage(img); // precise trimming
+
+    // ---------------- Use ORIGINAL object size (no fixed scaling) ----------------
+    const scaledW = trimmed.width;
+    const scaledH = trimmed.height;
+
+    // ---------------- Shadow padding ----------------
+    let shadowOffset = type === 'drop' ? 50 : type === 'flat' ? 40 : type === 'box' ? 40 : 200;
+    let extraTop = 0, extraBottom = 0, extraLeft = 0, extraRight = 0;
+
+    if (dir === 'back') {
+        extraBottom = shadowOffset;
+        extraLeft = shadowOffset;
+        extraRight = shadowOffset;
+    } 
+    if (dir === 'front') extraTop = shadowOffset;
+
+    if (type === 'cast') {
+        extraTop += scaledH * 0.5;
+        extraBottom += scaledH * 0.5;
+        if (dir === 'back') {
+            extraLeft += scaledW * 0.3;
+            extraRight += scaledW * 0.3;
+        }
+    }
+
+    // ---------------- Final canvas size = original size + padding ----------------
+    const canvasW = scaledW + extraLeft + extraRight;
+    const canvasH = scaledH + extraTop + extraBottom;
+    const canvas = createCanvas(canvasW, canvasH);
+    const ctx = canvas.getContext('2d');
+    ctx.clearRect(0, 0, canvasW, canvasH);
+
+    // ---------------- Base position ----------------
+    const baseX = extraLeft + scaledW / 2;  // center of object
+    const baseY = extraTop + scaledH;       // bottom of object
+
+    // ---------------- Draw shadow ----------------
+    switch (type) {
+        case 'drop':
+            drawDropShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, blur, opacity, baseX, baseY);
+            break;
+        case 'flat':
+            drawFlatShadow(ctx, trimmed.canvas, scaledW, scaledH, dir, opacity, baseX, baseY);
+            break;
+        case 'box':
+            drawBoxShadow(ctx, scaledW, scaledH, dir, blur, opacity, baseX, baseY);
+            break;
+        case 'cast':
+        default:
+            drawCastShadow(ctx, trimmed.canvas, scaledW, scaledH, blur, opacity, baseX, baseY, lightX, lightY, dir);
+            break;
+    }
+
+    // ---------------- Draw object ----------------
+    ctx.globalAlpha = 1;
+    ctx.filter = "none";
+    ctx.drawImage(trimmed.canvas, baseX - scaledW / 2, baseY - scaledH, scaledW, scaledH);
+
+    return canvas.toBuffer("image/png");
+}
+
+// ---------------- Shadow helpers ----------------
+function computePadOverlap(blur) {
+    const pad = Math.max(4, Math.ceil(blur * 2)); // ensures enough padding for blur spread
+    const overlap = Math.max(1, Math.round(blur * 0.6)); // shadow overlap with object
+    return { pad, overlap };
+}
+
+function drawDropShadow(ctx, img, w, h, dir, blur, opacity, baseX, baseY) {
+    let dx = 0, dy = 0, off = 40;
+    if (dir === 'back') dy = off;
+    if (dir === 'front') dy = -off;
+    if (dir === 'left') dx = -off;
+    if (dir === 'right') dx = off;
+
+    const { pad, overlap } = computePadOverlap(blur);
+
+    const shadowCanvas = createCanvas(Math.round(w + pad), Math.round(h + pad));
+    const sctx = shadowCanvas.getContext('2d');
+
+    const drawX = pad / 2;
+    const drawY = pad / 2;
+    sctx.clearRect(0, 0, shadowCanvas.width, shadowCanvas.height);
+    sctx.drawImage(img, drawX, drawY, w, h);
+    sctx.globalCompositeOperation = "source-in";
+    sctx.fillStyle = "black";
+    sctx.fillRect(0, 0, shadowCanvas.width, shadowCanvas.height);
+
+    StackBlur.canvasRGBA(shadowCanvas, 0, 0, shadowCanvas.width, shadowCanvas.height, blur);
+
+    ctx.save();
+    ctx.globalAlpha = opacity;
+    const drawPosX = baseX - w / 2 + dx - pad / 2;
+    const drawPosY = baseY - h + dy - pad / 2 + overlap;
+    ctx.drawImage(shadowCanvas, drawPosX, drawPosY, shadowCanvas.width, shadowCanvas.height);
+    ctx.restore();
+}
+
+function drawFlatShadow(ctx, img, w, h, dir, opacity, baseX, baseY) {
+    let dx = 0, dy = 0, off = 30;
+    if (dir === 'back') dy = off;
+    if (dir === 'front') dy = -off;
+    if (dir === 'left') dx = -off;
+    if (dir === 'right') dx = off;
+
+    ctx.save();
+    ctx.globalAlpha = opacity;
+    ctx.drawImage(img, baseX - w/2 + dx, baseY - h + dy + 1, w, h);
+    ctx.restore();
+}
+
+function drawBoxShadow(ctx, w, h, dir, blur, opacity, baseX, baseY) {
+    let dx = 0, dy = 0, off = 30;
+    if (dir === 'back') dy = off;
+    if (dir === 'front') dy = -off;
+    if (dir === 'left') dx = -off;
+    if (dir === 'right') dx = off;
+
+    const { pad, overlap } = computePadOverlap(blur);
+
+    const shadowCanvas = createCanvas(Math.round(w + pad), Math.round(h + pad));
+    const sctx = shadowCanvas.getContext('2d');
+    sctx.clearRect(0, 0, shadowCanvas.width, shadowCanvas.height);
+
+    sctx.fillStyle = `black`;
+    sctx.fillRect(pad/2, pad/2, w, h);
+
+    StackBlur.canvasRGBA(shadowCanvas, 0, 0, shadowCanvas.width, shadowCanvas.height, blur);
+
+    ctx.save();
+    ctx.globalAlpha = opacity;
+    const drawPosX = baseX - w/2 + dx - pad / 2;
+    const drawPosY = baseY - h + dy - pad / 2 + overlap;
+    ctx.drawImage(shadowCanvas, drawPosX, drawPosY, shadowCanvas.width, shadowCanvas.height);
+    ctx.restore();
+}
+
+function drawCastShadow(ctx, img, w, h, blur, opacity, baseX, baseY, lightX, lightY, dir) {
+    const { pad, overlap } = computePadOverlap(blur);
+    const shadowW = Math.round(w + pad);
+    const shadowH = Math.round(h + pad);
+    const shadowCanvas = createCanvas(shadowW, shadowH);
+    const sctx = shadowCanvas.getContext('2d');
+
+    sctx.clearRect(0, 0, shadowW, shadowH);
+    const drawX = pad / 2;
+    const drawY = pad / 2;
+    sctx.drawImage(img, drawX, drawY, w, h);
+    sctx.globalCompositeOperation = "source-in";
+    sctx.fillStyle = "black";
+    sctx.fillRect(0, 0, shadowW, shadowH);
+
+    StackBlur.canvasRGBA(shadowCanvas, 0, 0, shadowW, shadowH, blur);
+
+    const relX = lightX ? (lightX / (w * 2) - 0.5) * 2 : (dir === 'left' ? -1 : dir === 'right' ? 1 : 0);
+    const relY = lightY ? (lightY / (h * 2)) : (dir === 'front' ? 0.2 : dir === 'back' ? 0.8 : 0.5);
+    const skew = relX * 0.8;
+
+    ctx.save();
+    ctx.translate(baseX, baseY);
+    if (dir === 'front' || relY < 0.5) ctx.transform(1, 0, skew, -0.5, 0, 0);
+    else ctx.transform(1, 0, skew, 0.3, 0, 0);
+
+    ctx.globalAlpha = opacity;
+    const drawPosX = -w / 2 - pad / 2;
+    const drawPosY = -h - pad / 2 + overlap;
+    ctx.drawImage(shadowCanvas, drawPosX, drawPosY, shadowW, shadowH);
+
+    ctx.restore();
+}
+
+// ---------------- Trimming ----------------
+function trimImage(image) {
+    const temp = createCanvas(image.width, image.height);
+    const tctx = temp.getContext('2d');
+    tctx.drawImage(image, 0, 0);
+    const imgData = tctx.getImageData(0, 0, temp.width, temp.height);
+
+    let top = temp.height, left = temp.width, right = 0, bottom = 0;
+    for (let y = 0; y < temp.height; y++) {
+        for (let x = 0; x < temp.width; x++) {
+            const alpha = imgData.data[(y * temp.width + x) * 4 + 3];
+            if (alpha > 0) {
+                if (x < left) left = x;
+                if (x > right) right = x;
+                if (y < top) top = y;
+                if (y > bottom) bottom = y;
+            }
+        }
+    }
+
+    const w = right - left + 1;
+    const h = bottom - top + 1;
+    const trimmedCanvas = createCanvas(w, h);
+    const t2 = trimmedCanvas.getContext('2d');
+    t2.drawImage(image, left, top, w, h, 0, 0, w, h);
+
+    return { canvas: trimmedCanvas, width: w, height: h };
+}
+
+module.exports = { generateShadow };

app/queues/taskQueue.js

@@ -0,0 +1,162 @@
+// const { Queue, Worker, QueueScheduler, Job } = require('bullmq');
+// const IORedis = require('ioredis');
+// const fs = require('fs-extra');
+// const path = require('path');
+// const { v4: uuidv4 } = require('uuid');
+// const { generateShadow } = require('./shadowGenerator'); // your existing shadow logic
+
+// // Redis connection
+// const connection = new IORedis();
+
+// // Queue setup
+// const shadowQueue = new Queue('shadowQueue', { connection });
+// new QueueScheduler('shadowQueue', { connection });
+
+// // RAM and disk buffers
+// const RAM_LIMIT = 20; // max tasks in RAM
+// const RAM_BUFFER = [];
+// const DISK_BUFFER = path.join(__dirname, 'diskQueue');
+// fs.ensureDirSync(DISK_BUFFER);
+
+// // In-memory results
+// const RESULTS = {};
+
+// // ---------------- Add Task ----------------
+// async function addTask(fileBuffer, options = {}) {
+//     const taskId = uuidv4(); // unique ID for each task
+//     const task = { id: taskId, file: fileBuffer, options };
+
+//     if (RAM_BUFFER.length < RAM_LIMIT) {
+//         RAM_BUFFER.push(task);
+//         processRAMBuffer();
+//     } else {
+//         // Move to disk
+//         const filePath = path.join(DISK_BUFFER, `${taskId}.json`);
+//         await fs.writeJson(filePath, task, { spaces: 0 });
+//     }
+
+//     return taskId;
+// }
+
+// // ---------------- Process RAM tasks ----------------
+// let processing = false;
+
+// async function processRAMBuffer() {
+//     if (processing || RAM_BUFFER.length === 0) return;
+//     processing = true;
+
+//     while (RAM_BUFFER.length > 0) {
+//         const task = RAM_BUFFER.shift();
+//         try {
+//             const imgBuffer = await generateShadow(task.file, task.options);
+//             RESULTS[task.id] = imgBuffer;
+//         } catch (err) {
+//             console.error(`Task ${task.id} failed:`, err);
+//             RESULTS[task.id] = null;
+//         }
+
+//         // Move tasks from disk to RAM if space available
+//         const diskFiles = await fs.readdir(DISK_BUFFER);
+//         while (RAM_BUFFER.length < RAM_LIMIT && diskFiles.length > 0) {
+//             const diskFile = diskFiles.shift();
+//             const taskFromDisk = await fs.readJson(path.join(DISK_BUFFER, diskFile));
+//             RAM_BUFFER.push(taskFromDisk);
+//             await fs.remove(path.join(DISK_BUFFER, diskFile));
+//         }
+//     }
+
+//     processing = false;
+// }
+
+// // ---------------- Check Task Status ----------------
+// function getTaskStatus(taskId) {
+//     if (RESULTS[taskId] === undefined) return 'pending';
+//     if (RESULTS[taskId] === null) return 'failed';
+//     return 'done';
+// }
+
+// // ---------------- Fetch Result ----------------
+// function getTaskResult(taskId) {
+//     return RESULTS[taskId] || null;
+// }
+
+// module.exports = {
+//     addTask,
+//     getTaskStatus,
+//     getTaskResult
+// };
+
+
+const { v4: uuidv4 } = require('uuid');
+const { generateShadow } = require('../core/shadowGenerator');
+
+const RAM_LIMIT = 20;
+const RAM_BUFFER = [];
+const RESULTS = {};
+const CLEANUP_TIME = 10 * 60 * 1000; // 10 minutes
+
+let processing = false;
+
+// ---------------- Add Task ----------------
+async function addTask(fileBuffer, options = {}) {
+  const taskId = uuidv4();
+  const task = { id: taskId, file: fileBuffer, options };
+
+  if (RAM_BUFFER.length < RAM_LIMIT) {
+    RAM_BUFFER.push(task);
+    processRAMBuffer();
+  } else {
+    return Promise.reject(new Error('Server busy, try again'));
+  }
+
+  return taskId;
+}
+
+// ---------------- Process RAM tasks ----------------
+async function processRAMBuffer() {
+  if (processing || RAM_BUFFER.length === 0) return;
+  processing = true;
+
+  while (RAM_BUFFER.length > 0) {
+    const task = RAM_BUFFER.shift();
+    try {
+      const imgBuffer = await generateShadow(task.file, task.options);
+      RESULTS[task.id] = imgBuffer;
+
+      // Auto-clean after CLEANUP_TIME
+      setTimeout(() => {
+        delete RESULTS[task.id];
+      }, CLEANUP_TIME);
+
+    } catch (err) {
+      console.error(`Task ${task.id} failed:`, err);
+      RESULTS[task.id] = null;
+    }
+  }
+
+  processing = false;
+}
+
+// ---------------- Check Task Status ----------------
+function getTaskStatus(taskId) {
+  if (RESULTS[taskId] === undefined) return 'pending';
+  if (RESULTS[taskId] === null) return 'failed';
+  return 'done';
+}
+
+// ---------------- Fetch Result ----------------
+function getTaskResult(taskId) {
+  return RESULTS[taskId] || null;
+}
+
+// ---------------- Queue Length ----------------
+function getQueueLength() {
+  return RAM_BUFFER.length;
+}
+
+module.exports = {
+  addTask,
+  getTaskStatus,
+  getTaskResult,
+  getQueueLength
+};

app/server.js

@@ -0,0 +1,114 @@
+// const express = require('express');
+// const multer = require('multer');
+// const { addTask, getTaskStatus, getTaskResult } = require('../../queue');
+
+// const router = express.Router();
+// const upload = multer();
+
+// // ---------------- Submit new shadow task ----------------
+// router.post('/generate', upload.single('image'), async (req, res) => {
+//     if (!req.file) return res.status(400).json({ error: 'No image uploaded' });
+
+//     const options = {
+//         type: req.body.mode || 'cast',
+//         dir: req.body.dir || 'back',
+//         blur: parseInt(req.body.blur) || 20,
+//         opacity: parseFloat(req.body.opacity) || 0.35,
+//         lightX: req.body.lightX ? parseFloat(req.body.lightX) : undefined,
+//         lightY: req.body.lightY ? parseFloat(req.body.lightY) : undefined
+//     };
+
+//     try {
+//         const taskId = await addTask(req.file.buffer, options);
+//         res.json({ taskId });
+//     } catch (err) {
+//         console.error('Error adding task:', err);
+//         res.status(500).json({ error: 'Failed to add task' });
+//     }
+// });
+
+// // ---------------- Check task status ----------------
+// router.get('/status/:id', (req, res) => {
+//     const status = getTaskStatus(req.params.id);
+//     res.json({ status });
+// });
+
+// // ---------------- Fetch completed result ----------------
+// router.get('/result/:id', (req, res) => {
+//     const result = getTaskResult(req.params.id);
+//     if (!result) return res.status(404).json({ error: 'Result not ready' });
+
+//     res.set('Content-Type', 'image/png');
+//     res.send(result);
+// });
+
+// module.exports = router;
+
+
+const express = require('express');
+const multer = require('multer');
+const cors = require('cors');
+const {
+  addTask,
+  getTaskStatus,
+  getTaskResult,
+  getQueueLength
+} = require('./queues/taskQueue');
+
+const app = express();
+const router = express.Router();
+const upload = multer();
+
+app.use(cors());
+
+// ---------------- Submit new shadow task ----------------
+router.post('/add-shadow', upload.single('file'), async (req, res) => {
+  if (!req.file) return res.status(400).json({ error: 'No image uploaded' });
+
+  const options = {
+    type: req.body.type || 'cast',
+    dir: req.body.dir || 'back',
+    blur: req.body.blur ? parseInt(req.body.blur) : 20,
+    opacity: req.body.opacity ? parseFloat(req.body.opacity) : 0.35,
+    lightX: req.body.lightX ? parseFloat(req.body.lightX) : undefined,
+    lightY: req.body.lightY ? parseFloat(req.body.lightY) : undefined,
+  };
+
+  try {
+    const taskId = await addTask(req.file.buffer, options);
+    res.json({ task_id: taskId });
+  } catch (err) {
+    console.error('❌ Error adding shadow task:', err);
+    res.status(500).json({ error: 'Server busy, try again' });
+  }
+});
+
+// ---------------- Server load / status ----------------
+router.get('/status', (req, res) => {
+  res.json({
+    status: 'ok',
+    queue_length: getQueueLength(),
+  });
+});
+
+// ---------------- Poll for result ----------------
+router.get('/result/:id', (req, res) => {
+  const status = getTaskStatus(req.params.id);
+
+  if (status === 'pending') return res.sendStatus(202);
+  if (status === 'failed') return res.status(500).json({ error: 'Shadow generation failed' });
+
+  const result = getTaskResult(req.params.id);
+  if (!result) return res.status(404).json({ error: 'Result not found' });
+
+  res.set('Content-Type', 'image/png');
+  res.send(result);
+});
+
+app.use('/api/shadow', router);
+
+// ---------------- Start server ----------------
+const PORT = process.env.PORT || 5000;
+app.listen(PORT, () => console.log(`🚀 Shadow backend running on http://localhost:${PORT}`));
+
+module.exports = app;

package.json

@@ -0,0 +1,29 @@
+{
+  "name": "shadowbackend",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "body-parser": "^2.2.0",
+    "bullmq": "^5.58.2",
+    "canvas": "^3.2.0",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.1",
+    "express": "^5.1.0",
+    "fs-extra": "^11.3.1",
+    "ioredis": "^5.7.0",
+    "multer": "^2.0.2",
+    "sharp": "^0.34.3",
+    "stackblur-canvas": "^2.7.0",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.10"
+  }
+}

server.js

@@ -0,0 +1,114 @@
+// const express = require('express');
+// const multer = require('multer');
+// const { addTask, getTaskStatus, getTaskResult } = require('../../queue');
+
+// const router = express.Router();
+// const upload = multer();
+
+// // ---------------- Submit new shadow task ----------------
+// router.post('/generate', upload.single('image'), async (req, res) => {
+//     if (!req.file) return res.status(400).json({ error: 'No image uploaded' });
+
+//     const options = {
+//         type: req.body.mode || 'cast',
+//         dir: req.body.dir || 'back',
+//         blur: parseInt(req.body.blur) || 20,
+//         opacity: parseFloat(req.body.opacity) || 0.35,
+//         lightX: req.body.lightX ? parseFloat(req.body.lightX) : undefined,
+//         lightY: req.body.lightY ? parseFloat(req.body.lightY) : undefined
+//     };
+
+//     try {
+//         const taskId = await addTask(req.file.buffer, options);
+//         res.json({ taskId });
+//     } catch (err) {
+//         console.error('Error adding task:', err);
+//         res.status(500).json({ error: 'Failed to add task' });
+//     }
+// });
+
+// // ---------------- Check task status ----------------
+// router.get('/status/:id', (req, res) => {
+//     const status = getTaskStatus(req.params.id);
+//     res.json({ status });
+// });
+
+// // ---------------- Fetch completed result ----------------
+// router.get('/result/:id', (req, res) => {
+//     const result = getTaskResult(req.params.id);
+//     if (!result) return res.status(404).json({ error: 'Result not ready' });
+
+//     res.set('Content-Type', 'image/png');
+//     res.send(result);
+// });
+
+// module.exports = router;
+
+
+const express = require('express');
+const multer = require('multer');
+const cors = require('cors');
+const {
+  addTask,
+  getTaskStatus,
+  getTaskResult,
+  getQueueLength
+} = require('./queues/taskQueue');
+
+const app = express();
+const router = express.Router();
+const upload = multer();
+
+app.use(cors());
+
+// ---------------- Submit new shadow task ----------------
+router.post('/add-shadow', upload.single('file'), async (req, res) => {
+  if (!req.file) return res.status(400).json({ error: 'No image uploaded' });
+
+  const options = {
+    type: req.body.type || 'cast',
+    dir: req.body.dir || 'back',
+    blur: req.body.blur ? parseInt(req.body.blur) : 20,
+    opacity: req.body.opacity ? parseFloat(req.body.opacity) : 0.35,
+    lightX: req.body.lightX ? parseFloat(req.body.lightX) : undefined,
+    lightY: req.body.lightY ? parseFloat(req.body.lightY) : undefined,
+  };
+
+  try {
+    const taskId = await addTask(req.file.buffer, options);
+    res.json({ task_id: taskId });
+  } catch (err) {
+    console.error('❌ Error adding shadow task:', err);
+    res.status(500).json({ error: 'Server busy, try again' });
+  }
+});
+
+// ---------------- Server load / status ----------------
+router.get('/status', (req, res) => {
+  res.json({
+    status: 'ok',
+    queue_length: getQueueLength(),
+  });
+});
+
+// ---------------- Poll for result ----------------
+router.get('/result/:id', (req, res) => {
+  const status = getTaskStatus(req.params.id);
+
+  if (status === 'pending') return res.sendStatus(202);
+  if (status === 'failed') return res.status(500).json({ error: 'Shadow generation failed' });
+
+  const result = getTaskResult(req.params.id);
+  if (!result) return res.status(404).json({ error: 'Result not found' });
+
+  res.set('Content-Type', 'image/png');
+  res.send(result);
+});
+
+app.use('/api/shadow', router);
+
+// ---------------- Start server ----------------
+const PORT = process.env.PORT || 5000;
+app.listen(PORT, () => console.log(`🚀 Shadow backend running on http://localhost:${PORT}`));
+
+module.exports = app;