scan2form 1.2.3 → 1.3.0-dev.0

package/README.md

@@ -19,26 +19,20 @@ import { Scan2Form } from 'scan2form';
 
 const scanner = new Scan2Form();
 
-// Triggers the scan. 
-// If your input has accept="image/*", it scans as JPEG. Default is PDF.
+// Triggers the scan and populates the input with a PDF.
 await scanner.scanToInput('my-input');
-
-// OR use advanced options (e.g. for preview)
-await scanner.scan({
-    targetInputId: 'my-input', 
-    previewElementId: 'scan-preview'
-});
 ```
 
-## 🖼️ Supported Formats & Preview
-**Scan2Form** now supports multiple formats:
-*   **PDF** (Default)
-*   **JPEG / JPG**
-*   **PNG**
+## 🛠️ Handling Previews
+Since `scanToInput` returns the file object, you can easily display a preview yourself:
 
-To preview a scan immediately, simply provide the ID of an HTML element in `previewElementId`.
-*   For images, use an `<img>` tag.
-*   For PDFs, use `<iframe>`, `<embed>`, or `<object>`.
+```javascript
+const result = await scanner.scanToInput('my-input');
+if (result.success) {
+    const url = URL.createObjectURL(result.file);
+    document.getElementById('my-preview-iframe').src = url;
+}
+```
 
 That's it! The file input is now populated with a PDF, just as if the user uploaded it manually.
 

package/dist/bridge-server.js

@@ -7,157 +7,91 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.app = void 0;
 const express_1 = __importDefault(require("express"));
 const cors_1 = __importDefault(require("cors"));
-const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const uuid_1 = require("uuid");
+const config_1 = require("./config");
+const naps2_engine_1 = require("./engines/naps2-engine");
+const sane_engine_1 = require("./engines/sane-engine");
+const errors_1 = require("./errors");
 const app = (0, express_1.default)();
 exports.app = app;
-const PORT = 3000; // Localhost only
-// Rule 9.1: Bind only to localhost (enforced in listen)
-// Rule 9.3: Secure temp directory
-const TEMP_DIR = path_1.default.join(__dirname, 'temp_scans');
-if (!fs_1.default.existsSync(TEMP_DIR))
-    fs_1.default.mkdirSync(TEMP_DIR);
-app.use((0, cors_1.default)()); // Allow browser to hit localhost
+// Ensure temp directory exists
+if (!fs_1.default.existsSync(config_1.CONFIG.TEMP_DIR))
+    fs_1.default.mkdirSync(config_1.CONFIG.TEMP_DIR);
+app.use((0, cors_1.default)());
 app.use(express_1.default.json());
-// Rule 4.2: Health Check
-app.get('/health', (req, res) => {
-    res.json({ status: "ok", engine: "NAPS2-Wrapper", version: "1.0.0" });
+// Engine Selection Strategy
+const engines = [new naps2_engine_1.Naps2Engine(), new sane_engine_1.SaneEngine()];
+let cachedEngine = null;
+async function getEngine() {
+    if (cachedEngine)
+        return cachedEngine;
+    for (const engine of engines) {
+        if (await engine.isAvailable()) {
+            console.log(`Using Scanner Engine: ${engine.name}`);
+            cachedEngine = engine;
+            return engine;
+        }
+    }
+    throw new errors_1.ScanError('NO_ENGINE', 'No supported scanner software found (NAPS2 or SANE).', null, 500);
+}
+// --- Endpoints ---
+app.get('/health', async (req, res) => {
+    try {
+        const engine = await getEngine();
+        res.json({ status: "ok", engine: engine.name, version: "2.0.0" });
+    }
+    catch (e) {
+        res.status(503).json({ status: "error", error: "No Engine Available" });
+    }
 });
-// Serve example for testing
 app.use('/example', express_1.default.static(path_1.default.join(__dirname, '../example')));
 app.use('/dist', express_1.default.static(path_1.default.join(__dirname, '../dist')));
-// --- Scanner Engine Selection ---
-// We check for 'naps2.console' first, then 'scanimage' (SANE).
-function getScannerEngine(callback) {
-    (0, child_process_1.exec)('naps2.console --help', (err) => {
-        if (!err)
-            return callback('naps2');
-        (0, child_process_1.exec)('scanimage --version', (err2) => {
-            if (!err2)
-                return callback('sane');
-            callback(null);
-        });
-    });
-}
-// --- Endpoints ---
-app.get('/devices', (req, res) => {
-    getScannerEngine((engine) => {
-        if (engine === 'naps2') {
-            (0, child_process_1.exec)('naps2.console --list', (error, stdout, stderr) => {
-                if (error) {
-                    console.error("NAPS2 List Error:", stderr);
-                    return res.json([]);
-                }
-                const devices = stdout.split('\n').filter(line => line.trim().length > 0);
-                res.json({ devices });
-            });
-        }
-        else if (engine === 'sane') {
-            (0, child_process_1.exec)('scanimage -L', (error, stdout, stderr) => {
-                if (error) {
-                    console.error("SANE List Error:", stderr);
-                    return res.json([]);
-                }
-                // scanimage -L output: "device `epsonds:libusb:002:003' is a Epson DS-530 II"
-                // We want to return a friendly name or the ID.
-                const devices = stdout.split('\n')
-                    .filter(line => line.includes('is a'))
-                    .map(line => {
-                    // Cleanup string
-                    return line.replace('device `', '').replace(`'`, '');
-                });
-                res.json({ devices });
-            });
-        }
-        else {
-            const msg = "No scanner software found. Please install NAPS2 (Windows) or SANE (Mac/Linux).";
-            console.error(msg);
-            res.json({ devices: [], error: msg });
-        }
-    });
+app.get('/devices', async (req, res) => {
+    try {
+        const engine = await getEngine();
+        const devices = await engine.listDevices();
+        res.json({ devices });
+    }
+    catch (error) {
+        console.error("Device List Error:", error);
+        const status = error instanceof errors_1.ScanError ? error.httpStatus : 500;
+        res.status(status).json({ devices: [], error: error.message });
+    }
 });
 app.post('/scan', async (req, res) => {
     const scanId = (0, uuid_1.v4)();
-    // Default to PDF if not specified
     const format = (req.body.format || 'pdf').toLowerCase();
-    // Usage: format can be 'pdf', 'jpg', 'jpeg', 'png'
-    const allowedFormats = ['pdf', 'jpg', 'jpeg', 'png'];
-    if (!allowedFormats.includes(format)) {
-        return res.status(400).json({ error: "Invalid format. Supported: pdf, jpg, png" });
+    const deviceId = req.body.deviceId;
+    if (!config_1.CONFIG.ALLOWED_FORMATS.includes(format)) {
+        return res.status(400).json({ error: `Invalid format. Supported: ${config_1.CONFIG.ALLOWED_FORMATS.join(', ')}` });
     }
-    // Map format to file extension
     const ext = format === 'jpeg' ? 'jpg' : format;
-    const finalFilePath = path_1.default.join(TEMP_DIR, `scan_${scanId}.${ext}`);
-    getScannerEngine((engine) => {
-        if (!engine) {
-            return res.status(500).json({ error: "No scanner software installed (NAPS2 or SANE)." });
-        }
-        if (engine === 'naps2') {
-            // NAPS2 detects format by extension
-            const cmd = `naps2.console -o "${finalFilePath}" -v`;
-            console.log(`Scanning with NAPS2 (${format}): ${cmd}`);
-            (0, child_process_1.exec)(cmd, (error, stdout, stderr) => {
-                if (error) {
-                    console.error(`NAPS2 Error: ${error.message}`);
-                    const errorDetail = stderr || error.message;
-                    return res.status(500).json({ error: "Scan failed", details: errorDetail });
-                }
-                if (fs_1.default.existsSync(finalFilePath)) {
-                    res.sendFile(finalFilePath, () => {
-                        fs_1.default.unlink(finalFilePath, (err) => { if (err)
-                            console.error("Cleanup error:", err); });
-                    });
-                }
-                else {
-                    res.status(500).json({ error: "Scan completed but file not found.", details: "Output file missing." });
-                }
+    const finalFilePath = path_1.default.join(config_1.CONFIG.TEMP_DIR, `scan_${scanId}.${ext}`);
+    try {
+        const engine = await getEngine();
+        console.log(`Starting scan with ${engine.name}...`);
+        await engine.scan({ format, deviceId }, finalFilePath);
+        if (fs_1.default.existsSync(finalFilePath)) {
+            res.sendFile(finalFilePath, () => {
+                fs_1.default.unlink(finalFilePath, (err) => { if (err)
+                    console.error("Cleanup error:", err); });
             });
         }
-        else if (engine === 'sane') {
-            // SANE flow: scanimage -> tiff -> sips -> target format
-            const tempTiffPath = path_1.default.join(TEMP_DIR, `scan_${scanId}.tiff`);
-            const cmd = `scanimage --format=tiff --mode Color --resolution 300 > "${tempTiffPath}"`;
-            console.log(`Scanning with SANE: ${cmd}`);
-            (0, child_process_1.exec)(cmd, (error, stdout, stderr) => {
-                if (error) {
-                    console.error(`SANE Error: ${error.message}`);
-                    const errorDetail = stderr || error.message;
-                    return res.status(500).json({ error: "Scan failed", details: errorDetail });
-                }
-                // Convert TIFF to Target Format using 'sips'
-                // sips support: pdf, jpeg, png
-                let sipsFormat = format;
-                if (format === 'jpg')
-                    sipsFormat = 'jpeg';
-                const convertCmd = `sips -s format ${sipsFormat} "${tempTiffPath}" --out "${finalFilePath}"`;
-                console.log(`Converting: ${convertCmd}`);
-                (0, child_process_1.exec)(convertCmd, (cErr, cOut, cStderr) => {
-                    // Cleanup TIFF immediately
-                    if (fs_1.default.existsSync(tempTiffPath))
-                        fs_1.default.unlinkSync(tempTiffPath);
-                    if (cErr) {
-                        console.error(`Conversion Error: ${cStderr}`);
-                        return res.status(500).json({ error: "Image conversion failed" });
-                    }
-                    if (fs_1.default.existsSync(finalFilePath)) {
-                        res.sendFile(finalFilePath, () => {
-                            fs_1.default.unlink(finalFilePath, (err) => { if (err)
-                                console.error("Cleanup error:", err); });
-                        });
-                    }
-                    else {
-                        res.status(500).json({ error: "Conversion completed but file not found." });
-                    }
-                });
-            });
+        else {
+            throw new errors_1.ScanError('FILE_MISSING', 'Scan finished but output file is missing.', null, 500);
         }
-    });
+    }
+    catch (error) {
+        console.error("Scan Error:", error);
+        const status = error instanceof errors_1.ScanError ? error.httpStatus : 500;
+        res.status(status).json({ error: "Scan failed", details: error.message });
+    }
 });
 if (require.main === module) {
-    app.listen(PORT, '127.0.0.1', () => {
-        console.log(`Scan2Form Bridge running at http://127.0.0.1:${PORT}`);
-        console.log(`Open Example: http://127.0.0.1:${PORT}/example/index.html`);
+    app.listen(config_1.CONFIG.PORT, config_1.CONFIG.HOST, () => {
+        console.log(`Scan2Form Bridge running at http://${config_1.CONFIG.HOST}:${config_1.CONFIG.PORT}`);
+        console.log(`Open Example: http://${config_1.CONFIG.HOST}:${config_1.CONFIG.PORT}/example/index.html`);
     });
 }

package/dist/config.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
+const path_1 = __importDefault(require("path"));
+exports.CONFIG = {
+    PORT: process.env.PORT ? parseInt(process.env.PORT) : 3000,
+    HOST: process.env.HOST || '127.0.0.1',
+    TEMP_DIR: process.env.TEMP_DIR || path_1.default.join(__dirname, 'temp_scans'),
+    SCAN_TIMEOUT_MS: process.env.SCAN_TIMEOUT_MS ? parseInt(process.env.SCAN_TIMEOUT_MS) : 60000,
+    ALLOWED_FORMATS: ['pdf', 'jpg', 'jpeg', 'png'],
+};

package/dist/engines/naps2-engine.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Naps2Engine = void 0;
+const utils_1 = require("../utils");
+const errors_1 = require("../errors");
+class Naps2Engine {
+    constructor() {
+        this.name = 'naps2';
+    }
+    async isAvailable() {
+        try {
+            await (0, utils_1.runCommand)('naps2.console', ['--help'], 5000);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async listDevices() {
+        try {
+            const stdout = await (0, utils_1.runCommand)('naps2.console', ['--list']);
+            return stdout.split('\n')
+                .filter(line => line.trim().length > 0)
+                .map(line => ({ name: line.trim() }));
+        }
+        catch (e) {
+            throw new errors_1.ScanError('DEVICE_LIST_FAILED', 'Failed to list NAPS2 devices', e.message);
+        }
+    }
+    async scan(options, outputPath) {
+        try {
+            const args = ['-o', outputPath, '-v'];
+            // If deviceId is provided, NAPS2 might support it via specific flags or profile, 
+            // but for now we stick to default behavior or profile usage if previously configured.
+            // If explicit device name selection is needed, NAPS2 usually uses profiles.
+            await (0, utils_1.runCommand)('naps2.console', args);
+        }
+        catch (e) {
+            throw new errors_1.ScanError('SCAN_FAILED', 'NAPS2 scan failed', e.message);
+        }
+    }
+}
+exports.Naps2Engine = Naps2Engine;

package/dist/engines/sane-engine.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaneEngine = void 0;
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const utils_1 = require("../utils");
+const errors_1 = require("../errors");
+class SaneEngine {
+    constructor() {
+        this.name = 'sane';
+    }
+    async isAvailable() {
+        try {
+            await (0, utils_1.runCommand)('scanimage', ['--version'], 5000);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async listDevices() {
+        try {
+            const stdout = await (0, utils_1.runCommand)('scanimage', ['-L']);
+            return stdout.split('\n')
+                .filter(line => line.includes('is a'))
+                .map(line => {
+                const name = line.replace('device `', '').replace(`'`, '');
+                return { name };
+            });
+        }
+        catch (e) {
+            throw new errors_1.ScanError('DEVICE_LIST_FAILED', 'Failed to list SANE devices', e.message);
+        }
+    }
+    async scan(options, outputPath) {
+        const tempTiffPath = outputPath.replace(/\.\w+$/, '.tiff');
+        try {
+            // SANE Scan
+            const args = ['--format=tiff', '--mode', 'Color', '--resolution', '300'];
+            if (options.deviceId) {
+                args.push('-d', options.deviceId);
+                // Note: Device ID handling needs care given the string format, 
+                // but for SANE 'deviceId' is usually the name/address.
+            }
+            await new Promise((resolve, reject) => {
+                const fileStream = fs_1.default.createWriteStream(tempTiffPath);
+                const child = (0, child_process_1.spawn)('scanimage', args);
+                child.stdout.pipe(fileStream);
+                let stderr = '';
+                child.stderr.on('data', d => stderr += d);
+                child.on('close', (code) => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error(stderr || `SANE failed with code ${code}`));
+                });
+                child.on('error', reject);
+            });
+            // Conversion
+            let sipsFormat = options.format;
+            if (options.format === 'jpg')
+                sipsFormat = 'jpeg';
+            await (0, utils_1.runCommand)('sips', ['-s', 'format', sipsFormat, tempTiffPath, '--out', outputPath]);
+        }
+        catch (e) {
+            throw new errors_1.ScanError('SCAN_FAILED', 'SANE scan failed', e.message);
+        }
+        finally {
+            if (fs_1.default.existsSync(tempTiffPath))
+                fs_1.default.unlinkSync(tempTiffPath);
+        }
+    }
+}
+exports.SaneEngine = SaneEngine;

package/dist/engines/scanner-engine.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/errors.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanError = void 0;
+class ScanError extends Error {
+    constructor(code, message, details, httpStatus = 500) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.httpStatus = httpStatus;
+        this.name = 'ScanError';
+    }
+}
+exports.ScanError = ScanError;

package/dist/esm/scanner-client.js

@@ -2,85 +2,57 @@ export class Scan2Form {
     constructor(bridgeUrl = 'http://127.0.0.1:3000') {
         this.bridgeUrl = bridgeUrl;
     }
-    // Rule 5.1: Detect Bridge
     async isAvailable() {
         try {
             const res = await fetch(`${this.bridgeUrl}/health`);
-            return { success: res.ok };
+            if (res.ok)
+                return { success: true };
+            return { success: false, error: res.statusText };
         }
         catch (e) {
             return { success: false, error: e.message || "Network Error" };
         }
     }
-    // List available scanners
     async getDevices() {
         try {
             const res = await fetch(`${this.bridgeUrl}/devices`);
-            if (!res.ok)
-                return { devices: [], error: res.statusText };
             const data = await res.json();
-            return { devices: data.devices || [], error: data.error };
+            if (!res.ok) {
+                return { devices: [], error: data.error || data.message || res.statusText };
+            }
+            return {
+                devices: Array.isArray(data.devices)
+                    ? data.devices.map((d) => typeof d === 'string' ? d : d.name)
+                    : [],
+                error: data.error
+            };
         }
         catch (e) {
             return { devices: [], error: "Bridge unreachable" };
         }
     }
-    // Rule 5.2 & 5.3: Trigger Scan & Receive Blob
-    async scan(options) {
-        // Backward compatibility: if string, treat as inputId
-        let config = {};
-        if (typeof options === 'string') {
-            config = { targetInputId: options };
-        }
-        else {
-            config = { ...options };
-        }
-        // Rule 5.6: Auto-detect format from Input "accept" attribute if not specified
-        if (!config.format && config.targetInputId) {
-            const input = document.getElementById(config.targetInputId);
-            if (input && input.accept) {
-                const accept = input.accept.toLowerCase();
-                if (accept.includes('image/png')) {
-                    config.format = 'png';
-                }
-                else if (accept.includes('image/jpeg') || accept.includes('image/jpg') || accept.includes('image/*')) {
-                    config.format = 'jpeg'; // Default image format
-                }
-            }
-        }
-        // Default to PDF
-        if (!config.format)
-            config.format = 'pdf';
+    async scanToInput(inputId, options) {
+        const inputElement = document.getElementById(inputId);
+        if (!inputElement)
+            throw new Error("Input element not found");
         try {
             const response = await fetch(`${this.bridgeUrl}/scan`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ format: config.format })
+                body: JSON.stringify(options || {})
             });
             if (!response.ok) {
-                const errData = await response.json();
-                throw new Error(errData.details || "Scan failed or cancelled");
+                const errData = await response.json().catch(() => ({}));
+                throw new Error(errData.error || errData.details || "Scan failed");
             }
             const blob = await response.blob();
-            // Determine mime type based on format or blob
-            const mimeType = blob.type || (config.format === 'pdf' ? 'application/pdf' : `image/${config.format}`);
-            // Rule 5.4: Inject into DataTransfer
-            const ext = config.format === 'jpeg' ? 'jpg' : config.format;
+            const mimeType = blob.type || 'application/pdf';
+            const ext = mimeType === 'image/jpeg' ? 'jpg' : (mimeType.split('/')[1] || 'pdf');
             const file = new File([blob], `scanned_doc_${Date.now()}.${ext}`, { type: mimeType });
-            // Handle Input Population
-            if (config.targetInputId) {
-                const inputElement = document.getElementById(config.targetInputId);
-                if (inputElement) {
-                    const dataTransfer = new DataTransfer();
-                    dataTransfer.items.add(file);
-                    inputElement.files = dataTransfer.files;
-                    inputElement.dispatchEvent(new Event('change', { bubbles: true }));
-                }
-            }
-            // Handle Preview
-            if (config.previewElementId) {
-                this.handlePreview(config.previewElementId, file);
-            }
+            const dataTransfer = new DataTransfer();
+            dataTransfer.items.add(file);
+            inputElement.files = dataTransfer.files;
+            inputElement.dispatchEvent(new Event('change', { bubbles: true }));
             return { success: true, file: file };
         }
         catch (error) {
@@ -88,31 +60,4 @@ export class Scan2Form {
             return { success: false, error: error.message || "An unknown error occurred during scan." };
         }
     }
-    /**
-     * Alias for scan() to maintain backward compatibility, but now supports options.
-     */
-    async scanToInput(inputIdOrOptions) {
-        return this.scan(inputIdOrOptions);
-    }
-    handlePreview(elementId, file) {
-        const el = document.getElementById(elementId);
-        if (!el)
-            return;
-        const url = URL.createObjectURL(file);
-        const tagName = el.tagName.toLowerCase();
-        if (tagName === 'img') {
-            el.src = url;
-        }
-        else if (tagName === 'iframe') {
-            el.src = url;
-        }
-        else if (tagName === 'embed') {
-            el.src = url;
-            el.type = file.type;
-        }
-        else if (tagName === 'object') {
-            el.data = url;
-            el.type = file.type;
-        }
-    }
 }

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/scanner-client.js

@@ -5,85 +5,57 @@ class Scan2Form {
     constructor(bridgeUrl = 'http://127.0.0.1:3000') {
         this.bridgeUrl = bridgeUrl;
     }
-    // Rule 5.1: Detect Bridge
     async isAvailable() {
         try {
             const res = await fetch(`${this.bridgeUrl}/health`);
-            return { success: res.ok };
+            if (res.ok)
+                return { success: true };
+            return { success: false, error: res.statusText };
         }
         catch (e) {
             return { success: false, error: e.message || "Network Error" };
         }
     }
-    // List available scanners
     async getDevices() {
         try {
             const res = await fetch(`${this.bridgeUrl}/devices`);
-            if (!res.ok)
-                return { devices: [], error: res.statusText };
             const data = await res.json();
-            return { devices: data.devices || [], error: data.error };
+            if (!res.ok) {
+                return { devices: [], error: data.error || data.message || res.statusText };
+            }
+            return {
+                devices: Array.isArray(data.devices)
+                    ? data.devices.map((d) => typeof d === 'string' ? d : d.name)
+                    : [],
+                error: data.error
+            };
         }
         catch (e) {
             return { devices: [], error: "Bridge unreachable" };
         }
     }
-    // Rule 5.2 & 5.3: Trigger Scan & Receive Blob
-    async scan(options) {
-        // Backward compatibility: if string, treat as inputId
-        let config = {};
-        if (typeof options === 'string') {
-            config = { targetInputId: options };
-        }
-        else {
-            config = { ...options };
-        }
-        // Rule 5.6: Auto-detect format from Input "accept" attribute if not specified
-        if (!config.format && config.targetInputId) {
-            const input = document.getElementById(config.targetInputId);
-            if (input && input.accept) {
-                const accept = input.accept.toLowerCase();
-                if (accept.includes('image/png')) {
-                    config.format = 'png';
-                }
-                else if (accept.includes('image/jpeg') || accept.includes('image/jpg') || accept.includes('image/*')) {
-                    config.format = 'jpeg'; // Default image format
-                }
-            }
-        }
-        // Default to PDF
-        if (!config.format)
-            config.format = 'pdf';
+    async scanToInput(inputId, options) {
+        const inputElement = document.getElementById(inputId);
+        if (!inputElement)
+            throw new Error("Input element not found");
         try {
             const response = await fetch(`${this.bridgeUrl}/scan`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ format: config.format })
+                body: JSON.stringify(options || {})
             });
             if (!response.ok) {
-                const errData = await response.json();
-                throw new Error(errData.details || "Scan failed or cancelled");
+                const errData = await response.json().catch(() => ({}));
+                throw new Error(errData.error || errData.details || "Scan failed");
             }
             const blob = await response.blob();
-            // Determine mime type based on format or blob
-            const mimeType = blob.type || (config.format === 'pdf' ? 'application/pdf' : `image/${config.format}`);
-            // Rule 5.4: Inject into DataTransfer
-            const ext = config.format === 'jpeg' ? 'jpg' : config.format;
+            const mimeType = blob.type || 'application/pdf';
+            const ext = mimeType === 'image/jpeg' ? 'jpg' : (mimeType.split('/')[1] || 'pdf');
             const file = new File([blob], `scanned_doc_${Date.now()}.${ext}`, { type: mimeType });
-            // Handle Input Population
-            if (config.targetInputId) {
-                const inputElement = document.getElementById(config.targetInputId);
-                if (inputElement) {
-                    const dataTransfer = new DataTransfer();
-                    dataTransfer.items.add(file);
-                    inputElement.files = dataTransfer.files;
-                    inputElement.dispatchEvent(new Event('change', { bubbles: true }));
-                }
-            }
-            // Handle Preview
-            if (config.previewElementId) {
-                this.handlePreview(config.previewElementId, file);
-            }
+            const dataTransfer = new DataTransfer();
+            dataTransfer.items.add(file);
+            inputElement.files = dataTransfer.files;
+            inputElement.dispatchEvent(new Event('change', { bubbles: true }));
             return { success: true, file: file };
         }
         catch (error) {
@@ -91,32 +63,5 @@ class Scan2Form {
             return { success: false, error: error.message || "An unknown error occurred during scan." };
         }
     }
-    /**
-     * Alias for scan() to maintain backward compatibility, but now supports options.
-     */
-    async scanToInput(inputIdOrOptions) {
-        return this.scan(inputIdOrOptions);
-    }
-    handlePreview(elementId, file) {
-        const el = document.getElementById(elementId);
-        if (!el)
-            return;
-        const url = URL.createObjectURL(file);
-        const tagName = el.tagName.toLowerCase();
-        if (tagName === 'img') {
-            el.src = url;
-        }
-        else if (tagName === 'iframe') {
-            el.src = url;
-        }
-        else if (tagName === 'embed') {
-            el.src = url;
-            el.type = file.type;
-        }
-        else if (tagName === 'object') {
-            el.data = url;
-            el.type = file.type;
-        }
-    }
 }
 exports.Scan2Form = Scan2Form;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+const child_process_1 = require("child_process");
+const config_1 = require("./config");
+function runCommand(command, args, timeoutMs = config_1.CONFIG.SCAN_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args);
+        let stdout = '';
+        let stderr = '';
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error(`Command timed out after ${timeoutMs}ms: ${command} ${args.join(' ')}`));
+        }, timeoutMs);
+        child.stdout.on('data', (data) => { stdout += data.toString(); });
+        child.stderr.on('data', (data) => { stderr += data.toString(); });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve(stdout);
+            }
+            else {
+                reject(new Error(stderr || `Command failed with code ${code}`));
+            }
+        });
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scan2form",
-  "version": "1.2.3",
+  "version": "1.3.0-dev.0",
   "description": "Local offline bridge allowing web browsers to access physical scanners (WIA, TWAIN, SANE).",
   "main": "dist/scanner-client.js",
   "scripts": {