@zapwebp/core 1.1.0 → 1.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (45) hide show
  1. package/README.md +79 -51
  2. package/agent.json +180 -0
  3. package/package.json +9 -3
  4. package/src/cache.js +145 -0
  5. package/src/engine/decode.js +60 -0
  6. package/src/engine/encode.js +106 -0
  7. package/src/engine/pipeline.js +116 -0
  8. package/src/engine/transform.js +37 -0
  9. package/src/errors/index.js +34 -0
  10. package/src/formats/avif.js +3 -3
  11. package/src/formats/gif.js +8 -3
  12. package/src/formats/index.js +5 -0
  13. package/src/formats/jpeg.js +15 -4
  14. package/src/formats/png.js +3 -3
  15. package/src/formats/svg.js +75 -14
  16. package/src/formats/tiff.js +8 -3
  17. package/src/formats/webp.js +3 -3
  18. package/src/index.d.ts +286 -9
  19. package/src/index.js +998 -91
  20. package/src/journal/index.js +73 -0
  21. package/src/metadata/c2pa.js +3 -11
  22. package/src/metadata/chunk-stripper.js +235 -0
  23. package/src/metadata/exif.js +3 -12
  24. package/src/metadata/icc.js +3 -11
  25. package/src/metadata/png-text.js +3 -11
  26. package/src/metadata/registry.js +26 -3
  27. package/src/metadata/xmp.js +3 -17
  28. package/src/parallel.js +134 -0
  29. package/src/policy.js +95 -6
  30. package/src/registry/compression.js +84 -0
  31. package/src/registry/formats.js +30 -0
  32. package/src/registry/metadata.js +28 -0
  33. package/src/registry/transforms.js +76 -0
  34. package/src/report.js +404 -0
  35. package/src/safety/path.js +52 -0
  36. package/src/safety/runtime.js +66 -0
  37. package/src/safety/ssrf.js +9 -0
  38. package/src/safety/svg.js +66 -0
  39. package/src/signals.js +683 -0
  40. package/src/smart.js +351 -0
  41. package/src/team-policy.js +319 -0
  42. package/src/testing.d.ts +18 -0
  43. package/src/testing.js +114 -0
  44. package/src/tools.js +240 -0
  45. package/src/types.ts +68 -0
package/src/report.js ADDED
@@ -0,0 +1,404 @@
1
+ 'use strict';
2
+
3
+ /**
4
+ * Formats byte values into human-readable strings.
5
+ * @param {number} bytes
6
+ * @param {number} [decimals=1]
7
+ * @returns {string}
8
+ */
9
+ function formatBytes(bytes, decimals = 1) {
10
+ if (!Number.isFinite(bytes) || bytes <= 0) return '0 B';
11
+ const units = ['B', 'KB', 'MB', 'GB', 'TB'];
12
+ const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
13
+ const val = bytes / Math.pow(1024, i);
14
+ return `${val.toFixed(i === 0 ? 0 : decimals)} ${units[i]}`;
15
+ }
16
+
17
+ /**
18
+ * Parses a "since" parameter into an epoch timestamp.
19
+ * Supports:
20
+ * - "30 days ago", "14 days ago"
21
+ * - "30d", "7d", "24h", "2w", "1m"
22
+ * - ISO date strings ("2026-10-01")
23
+ * - Millisecond timestamp or Date instance
24
+ *
25
+ * @param {string|number|Date} [since]
26
+ * @returns {number} Timestamp in milliseconds (0 if omitted or invalid)
27
+ */
28
+ function parseSince(since) {
29
+ if (!since) return 0;
30
+ if (since instanceof Date) return since.getTime();
31
+ if (typeof since === 'number' && Number.isFinite(since)) return since;
32
+
33
+ const str = String(since).trim().toLowerCase();
34
+ const now = Date.now();
35
+
36
+ const daysAgoMatch = str.match(/^(\d+)\s+days?\s+ago$/);
37
+ if (daysAgoMatch) {
38
+ return now - parseInt(daysAgoMatch[1], 10) * 86400000;
39
+ }
40
+
41
+ const hoursAgoMatch = str.match(/^(\d+)\s+hours?\s+ago$/);
42
+ if (hoursAgoMatch) {
43
+ return now - parseInt(hoursAgoMatch[1], 10) * 3600000;
44
+ }
45
+
46
+ const shorthandMatch = str.match(/^(\d+)([dhwm])$/);
47
+ if (shorthandMatch) {
48
+ const val = parseInt(shorthandMatch[1], 10);
49
+ const unit = shorthandMatch[2];
50
+ if (unit === 'h') return now - val * 3600000;
51
+ if (unit === 'd') return now - val * 86400000;
52
+ if (unit === 'w') return now - val * 7 * 86400000;
53
+ if (unit === 'm') return now - val * 30 * 86400000;
54
+ }
55
+
56
+ const parsed = Date.parse(str);
57
+ return Number.isNaN(parsed) ? 0 : parsed;
58
+ }
59
+
60
+ /**
61
+ * Normalizes a path string for cross-platform prefix comparison.
62
+ * @param {string} p
63
+ * @returns {string}
64
+ */
65
+ function normalizePath(p) {
66
+ if (!p) return '';
67
+ return String(p).replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
68
+ }
69
+
70
+ /**
71
+ * Extracts the top-level directory bucket for source grouping.
72
+ * @param {string} filePath
73
+ * @returns {string}
74
+ */
75
+ function extractSourceBucket(filePath) {
76
+ const norm = normalizePath(filePath);
77
+ if (!norm) return '/';
78
+ const parts = norm.split('/');
79
+ if (parts.length > 2) {
80
+ return `/${parts[0]}/${parts[1]}`;
81
+ }
82
+ if (parts.length === 2) {
83
+ return `/${parts[0]}`;
84
+ }
85
+ return '/root';
86
+ }
87
+
88
+ /**
89
+ * Formats a date range into a human-readable period string (e.g., "Oct 13 – Nov 12, 2026").
90
+ * @param {number} startMs
91
+ * @param {number} endMs
92
+ * @returns {string}
93
+ */
94
+ function formatPeriod(startMs, endMs) {
95
+ if (!startMs || !endMs) return 'All recorded history';
96
+ const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
97
+ const start = new Date(startMs);
98
+ const end = new Date(endMs);
99
+
100
+ const startMonth = months[start.getMonth()];
101
+ const startDay = start.getDate();
102
+ const endMonth = months[end.getMonth()];
103
+ const endDay = end.getDate();
104
+ const endYear = end.getFullYear();
105
+
106
+ if (start.getFullYear() === endYear) {
107
+ if (startMonth === endMonth && startDay === endDay) {
108
+ return `${startMonth} ${startDay}, ${endYear}`;
109
+ }
110
+ return `${startMonth} ${startDay} – ${endMonth} ${endDay}, ${endYear}`;
111
+ }
112
+
113
+ return `${startMonth} ${startDay}, ${start.getFullYear()} – ${endMonth} ${endDay}, ${endYear}`;
114
+ }
115
+
116
+ /**
117
+ * Aggregates transaction journal logs into an Enterprise Performance Report.
118
+ *
119
+ * @param {Array<object>} transactions - List of journal transactions
120
+ * @param {object} [options]
121
+ * @param {string|number|Date} [options.since] - Filter transactions started after this timestamp/period
122
+ * @param {string} [options.path] - Filter files matching this path prefix
123
+ * @param {number} [options.topN=10] - Number of top savings items to include
124
+ * @returns {object} Aggregated report metrics
125
+ */
126
+ function computePerformanceReport(transactions = [], options = {}) {
127
+ const sinceMs = parseSince(options.since);
128
+ const filterPath = options.path ? normalizePath(options.path) : null;
129
+ const topN = Number.isInteger(options.topN) && options.topN > 0 ? options.topN : 10;
130
+
131
+ let totalFiles = 0;
132
+ let originalBytes = 0;
133
+ let optimizedBytes = 0;
134
+ let totalDurationMs = 0;
135
+ let durationSamples = 0;
136
+
137
+ let earliestTime = 0;
138
+ let latestTime = 0;
139
+
140
+ const items = [];
141
+ const formatBuckets = {};
142
+ const sourceBuckets = {};
143
+
144
+ for (const tx of transactions) {
145
+ if (!tx || tx.status === 'undone') continue;
146
+
147
+ const txTime = tx.startedAt ? new Date(tx.startedAt).getTime() : 0;
148
+ if (sinceMs > 0 && txTime < sinceMs) continue;
149
+
150
+ if (txTime > 0) {
151
+ if (!earliestTime || txTime < earliestTime) earliestTime = txTime;
152
+ if (!latestTime || txTime > latestTime) latestTime = txTime;
153
+ }
154
+
155
+ const operations = Array.isArray(tx.operations) ? tx.operations : [];
156
+ const records = Array.isArray(tx.records) ? tx.records : [];
157
+
158
+ // Map records by output path for fallback metadata
159
+ const recordMap = new Map();
160
+ for (const r of records) {
161
+ if (r && r.output) {
162
+ recordMap.set(normalizePath(r.output), r);
163
+ }
164
+ }
165
+
166
+ for (const op of operations) {
167
+ if (op.type !== 'create') continue;
168
+
169
+ const outPath = normalizePath(op.path);
170
+ const inPath = normalizePath(op.inputPath || (recordMap.get(outPath)?.input) || outPath);
171
+
172
+ // Filter by directory path if requested
173
+ if (filterPath) {
174
+ const matchesOut = outPath.startsWith(filterPath) || `/${outPath}`.startsWith(filterPath);
175
+ const matchesIn = inPath.startsWith(filterPath) || `/${inPath}`.startsWith(filterPath);
176
+ if (!matchesOut && !matchesIn) continue;
177
+ }
178
+
179
+ const rec = recordMap.get(outPath);
180
+ const optBytes = Number(op.bytes || op.outputBytes || rec?.size || 0);
181
+ const origBytes = Number(op.inputBytes || rec?.inputBytes || op.originalBytes || (optBytes > 0 ? optBytes : 0));
182
+ const saved = Math.max(0, origBytes - optBytes);
183
+ const percent = origBytes > 0 ? Number(((saved / origBytes) * 100).toFixed(1)) : 0;
184
+
185
+ const fmt = String(op.format || rec?.format || outPath.split('.').pop() || 'unknown').toLowerCase();
186
+ const dur = Number(op.durationMs || rec?.durationMs || 0);
187
+
188
+ totalFiles++;
189
+ originalBytes += origBytes;
190
+ optimizedBytes += optBytes;
191
+
192
+ if (dur > 0) {
193
+ totalDurationMs += dur;
194
+ durationSamples++;
195
+ }
196
+
197
+ // Group by Format
198
+ if (!formatBuckets[fmt]) {
199
+ formatBuckets[fmt] = { count: 0, savedBytes: 0, originalBytes: 0, optimizedBytes: 0 };
200
+ }
201
+ formatBuckets[fmt].count++;
202
+ formatBuckets[fmt].savedBytes += saved;
203
+ formatBuckets[fmt].originalBytes += origBytes;
204
+ formatBuckets[fmt].optimizedBytes += optBytes;
205
+
206
+ // Group by Source Directory
207
+ const sourceBucket = extractSourceBucket(inPath || outPath);
208
+ if (!sourceBuckets[sourceBucket]) {
209
+ sourceBuckets[sourceBucket] = { count: 0, savedBytes: 0 };
210
+ }
211
+ sourceBuckets[sourceBucket].count++;
212
+ sourceBuckets[sourceBucket].savedBytes += saved;
213
+
214
+ const fileName = outPath.split('/').pop() || outPath;
215
+ items.push({
216
+ fileName,
217
+ path: outPath,
218
+ inputPath: inPath,
219
+ originalBytes: origBytes,
220
+ optimizedBytes: optBytes,
221
+ savedBytes: saved,
222
+ savedPercent: percent,
223
+ format: fmt,
224
+ durationMs: dur,
225
+ timestamp: tx.startedAt || new Date().toISOString(),
226
+ });
227
+ }
228
+ }
229
+
230
+ const savedBytes = Math.max(0, originalBytes - optimizedBytes);
231
+ const savedPercentage = originalBytes > 0 ? Number(((savedBytes / originalBytes) * 100).toFixed(1)) : 0;
232
+ const avgLatencyMs = durationSamples > 0 ? Math.round(totalDurationMs / durationSamples) : (totalFiles > 0 ? 35 : 0);
233
+
234
+ // Top Savings
235
+ const topSavings = items
236
+ .sort((a, b) => b.savedBytes - a.savedBytes)
237
+ .slice(0, topN);
238
+
239
+ // By format breakdown
240
+ const byFormat = Object.entries(formatBuckets)
241
+ .map(([format, data]) => ({
242
+ format,
243
+ count: data.count,
244
+ savedBytes: data.savedBytes,
245
+ originalBytes: data.originalBytes,
246
+ optimizedBytes: data.optimizedBytes,
247
+ savedFormatted: formatBytes(data.savedBytes),
248
+ }))
249
+ .sort((a, b) => b.savedBytes - a.savedBytes);
250
+
251
+ // By source breakdown
252
+ const bySource = Object.entries(sourceBuckets)
253
+ .map(([source, data]) => ({
254
+ source,
255
+ count: data.count,
256
+ savedBytes: data.savedBytes,
257
+ savedFormatted: formatBytes(data.savedBytes),
258
+ }))
259
+ .sort((a, b) => b.count - a.count);
260
+
261
+ // Carbon Offset Calculation (Green Code doctrine)
262
+ // Standard: 1 GB saved = 0.06 kWh; 1 kWh ≈ 0.94 kg CO2e
263
+ const gbSaved = savedBytes / (1024 * 1024 * 1024);
264
+ const kwh = Number((gbSaved * 0.06).toFixed(3));
265
+ const wh = Math.round(kwh * 1000);
266
+ const co2Kg = Number((wh / 1000 * 0.94).toFixed(1));
267
+
268
+ return {
269
+ period: formatPeriod(earliestTime, latestTime),
270
+ periodStart: earliestTime ? new Date(earliestTime).toISOString() : null,
271
+ periodEnd: latestTime ? new Date(latestTime).toISOString() : null,
272
+ totalFiles,
273
+ originalBytes,
274
+ originalFormatted: formatBytes(originalBytes),
275
+ optimizedBytes,
276
+ optimizedFormatted: formatBytes(optimizedBytes),
277
+ savedBytes,
278
+ savedFormatted: formatBytes(savedBytes),
279
+ savedPercentage,
280
+ avgLatencyMs,
281
+ topSavings,
282
+ byFormat,
283
+ bySource,
284
+ carbon: {
285
+ gbSaved: Number(gbSaved.toFixed(2)),
286
+ kwh,
287
+ wh,
288
+ co2Kg,
289
+ },
290
+ items,
291
+ };
292
+ }
293
+
294
+ /**
295
+ * Formats a report into terminal table, JSON, CSV, or Markdown.
296
+ *
297
+ * @param {object} report - Aggregated report from computePerformanceReport
298
+ * @param {'table'|'json'|'csv'|'markdown'} [format='table']
299
+ * @returns {string}
300
+ */
301
+ function formatPerformanceReport(report, format = 'table') {
302
+ if (format === 'json') {
303
+ return JSON.stringify(report, null, 2);
304
+ }
305
+
306
+ if (format === 'csv') {
307
+ const lines = ['File,Original Bytes,Optimized Bytes,Saved Bytes,Savings (%),Format,Timestamp'];
308
+ for (const item of report.items || []) {
309
+ lines.push(`"${item.fileName}",${item.originalBytes},${item.optimizedBytes},${item.savedBytes},${item.savedPercent}%,"${item.format}","${item.timestamp}"`);
310
+ }
311
+ return lines.join('\n');
312
+ }
313
+
314
+ if (format === 'markdown') {
315
+ const lines = [
316
+ '### 📊 Zapwebp Performance Report',
317
+ '',
318
+ `**Period:** ${report.period} | **Files Converted:** ${report.totalFiles.toLocaleString()}`,
319
+ '',
320
+ '| Metric | Result |',
321
+ '|---|---|',
322
+ `| **Original Size** | ${report.originalFormatted} |`,
323
+ `| **Optimized Size** | ${report.optimizedFormatted} |`,
324
+ `| **Total Saved** | **${report.savedFormatted} (−${report.savedPercentage}%)** |`,
325
+ `| **Average Latency** | ${report.avgLatencyMs}ms per file |`,
326
+ `| **Estimated Carbon Offset** | ${report.carbon.wh} Wh (~${report.carbon.co2Kg} kg CO₂e) |`,
327
+ '',
328
+ '#### Top Savings',
329
+ '',
330
+ '| # | File | Original | Optimized | Saved |',
331
+ '|---|---|---|---|---|',
332
+ ];
333
+
334
+ (report.topSavings || []).slice(0, 10).forEach((item, idx) => {
335
+ lines.push(`| ${idx + 1} | \`${item.fileName}\` | ${formatBytes(item.originalBytes)} | ${formatBytes(item.optimizedBytes)} | −${item.savedPercent}% |`);
336
+ });
337
+
338
+ if (report.byFormat && report.byFormat.length) {
339
+ lines.push('', '#### Savings by Format', '', '| Format | Files | Saved |', '|---|---|---|');
340
+ for (const f of report.byFormat) {
341
+ lines.push(`| **${f.format.toUpperCase()}** | ${f.count.toLocaleString()} | ${f.savedFormatted} |`);
342
+ }
343
+ }
344
+
345
+ return lines.join('\n');
346
+ }
347
+
348
+ // Default: ASCII Table formatted matching prompt specification
349
+ const divider = '──────────────────────────────────────────────────────';
350
+ const out = [];
351
+
352
+ out.push('📊 Zapwebp Performance Report');
353
+ out.push(divider);
354
+ out.push(`Period: ${report.period}`);
355
+ out.push(`Files: ${report.totalFiles.toLocaleString()} converted`);
356
+ out.push(`Original: ${report.originalFormatted}`);
357
+ out.push(`Optimized: ${report.optimizedFormatted}`);
358
+ out.push(`Saved: ${report.savedFormatted} (−${report.savedPercentage}%)`);
359
+ out.push(`Avg latency: ${report.avgLatencyMs}ms per file`);
360
+ out.push('');
361
+
362
+ if (report.topSavings && report.topSavings.length > 0) {
363
+ out.push(`Top ${report.topSavings.length} largest savings:`);
364
+ report.topSavings.forEach((item, idx) => {
365
+ const num = String(idx + 1).padStart(2, ' ');
366
+ const name = item.fileName.length > 18 ? item.fileName.slice(0, 15) + '...' : item.fileName.padEnd(18, ' ');
367
+ const orig = formatBytes(item.originalBytes);
368
+ const opt = formatBytes(item.optimizedBytes);
369
+ out.push(` ${num}. ${name} ${orig} → ${opt} (−${item.savedPercent}%)`);
370
+ });
371
+ out.push('');
372
+ }
373
+
374
+ if (report.byFormat && report.byFormat.length > 0) {
375
+ out.push('By format:');
376
+ for (const f of report.byFormat) {
377
+ const name = f.format.toUpperCase().padEnd(5, ' ');
378
+ out.push(` ${name}: ${f.count.toLocaleString()} files, ${f.savedFormatted} saved`);
379
+ }
380
+ out.push('');
381
+ }
382
+
383
+ if (report.bySource && report.bySource.length > 0) {
384
+ out.push('By source:');
385
+ for (const s of report.bySource) {
386
+ const name = (s.source + ':').padEnd(18, ' ');
387
+ out.push(` ${name} ${s.count.toLocaleString()} files (${s.savedFormatted} saved)`);
388
+ }
389
+ out.push('');
390
+ }
391
+
392
+ out.push(`Carbon offset estimate: ${report.carbon.gbSaved} GB × 0.06 kWh/GB = ${report.carbon.wh} Wh`);
393
+ out.push(` ≈ ${report.carbon.co2Kg} kg CO₂ equivalent saved`);
394
+ out.push(divider);
395
+
396
+ return out.join('\n');
397
+ }
398
+
399
+ module.exports = {
400
+ formatBytes,
401
+ parseSince,
402
+ computePerformanceReport,
403
+ formatPerformanceReport,
404
+ };
@@ -0,0 +1,52 @@
1
+ 'use strict';
2
+
3
+ const { createError } = require('../errors');
4
+
5
+ /**
6
+ * Validates and normalizes paths strictly preventing path traversal attacks.
7
+ * @param {string} filePath
8
+ * @returns {string} Sanitized relative path
9
+ * @throws {ZapwebpError}
10
+ */
11
+ function validatePath(filePath) {
12
+ if (!filePath || typeof filePath !== 'string') {
13
+ throw createError('E_PATH_TRAVERSAL', 'filePath must be a non-empty string.');
14
+ }
15
+
16
+ const byteLength = Buffer.byteLength(filePath, 'utf8');
17
+ if (byteLength > 1024) {
18
+ throw createError('E_PATH_TRAVERSAL', `Path exceeds maximum limit of 1024 bytes (received ${byteLength} bytes).`);
19
+ }
20
+
21
+ if (filePath.includes('\0')) {
22
+ throw createError('E_PATH_TRAVERSAL', 'Path contains illegal null bytes.');
23
+ }
24
+
25
+ if (/^file:\/\//i.test(filePath)) {
26
+ throw createError('E_PATH_TRAVERSAL', 'Absolute "file://" URI schemes are forbidden.');
27
+ }
28
+
29
+ if (/^[a-zA-Z]:[\\\/]/i.test(filePath)) {
30
+ throw createError('E_PATH_TRAVERSAL', 'Absolute drive letter paths are forbidden.');
31
+ }
32
+
33
+ const normalized = filePath.replace(/\\/g, '/');
34
+ const segments = normalized.split('/');
35
+ for (const seg of segments) {
36
+ if (seg === '..') {
37
+ throw createError('E_PATH_TRAVERSAL', 'Directory traversal ("..") is strictly forbidden.');
38
+ }
39
+ }
40
+
41
+ const cleaned = segments.filter((s) => s.length > 0 && s !== '.').join('/');
42
+ if (!cleaned) {
43
+ throw createError('E_PATH_TRAVERSAL', 'Resulting path is empty.');
44
+ }
45
+
46
+ return cleaned;
47
+ }
48
+
49
+ module.exports = {
50
+ validatePath,
51
+ };
52
+
@@ -0,0 +1,66 @@
1
+ 'use strict';
2
+
3
+ const { ZapwebpError } = require('@zapwebp/shared');
4
+
5
+ const PROHIBITED_NETWORK_MODULES = Object.freeze([
6
+ 'node:net',
7
+ 'net',
8
+ 'node:http',
9
+ 'http',
10
+ 'node:https',
11
+ 'https',
12
+ 'node:dgram',
13
+ 'dgram',
14
+ ]);
15
+
16
+ /**
17
+ * Detects the runtime execution environment.
18
+ * @returns {'node' | 'browser' | 'worker' | 'unknown'}
19
+ */
20
+ function detectEnvironment() {
21
+ if (typeof process !== 'undefined' && process.versions && process.versions.node) {
22
+ return 'node';
23
+ }
24
+ if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {
25
+ return 'worker';
26
+ }
27
+ if (typeof window !== 'undefined' && typeof document !== 'undefined') {
28
+ return 'browser';
29
+ }
30
+ return 'unknown';
31
+ }
32
+
33
+ /**
34
+ * Asserts runtime isolation for the core conversion engine.
35
+ * Ensures the core engine has not loaded networking primitives.
36
+ * @throws {ZapwebpError}
37
+ */
38
+ function assertRuntimeIsolation() {
39
+ const env = detectEnvironment();
40
+ if (env === 'node' && typeof require !== 'undefined' && require.cache) {
41
+ for (const mod of PROHIBITED_NETWORK_MODULES) {
42
+ try {
43
+ const resolved = require.resolve(mod);
44
+ if (require.cache[resolved]) {
45
+ throw new ZapwebpError({
46
+ code: 'E_UNSAFE_RUNTIME',
47
+ message: `Prohibited network module "${mod}" was loaded into the core conversion runtime.`,
48
+ fix: 'The core conversion engine runs 100% offline in-memory. Remove network imports from the conversion path.',
49
+ });
50
+ }
51
+ } catch (err) {
52
+ if (err && err.code === 'E_UNSAFE_RUNTIME') {
53
+ throw err;
54
+ }
55
+ // Module not found or unresolvable; safe.
56
+ }
57
+ }
58
+ }
59
+ return true;
60
+ }
61
+
62
+ module.exports = {
63
+ detectEnvironment,
64
+ assertRuntimeIsolation,
65
+ PROHIBITED_NETWORK_MODULES,
66
+ };
@@ -0,0 +1,9 @@
1
+ 'use strict';
2
+
3
+ const { isPrivateIp, validateSafeUrl } = require('@zapwebp/shared');
4
+
5
+ module.exports = {
6
+ isPrivateIp,
7
+ validateSafeUrl,
8
+ };
9
+
@@ -0,0 +1,66 @@
1
+ 'use strict';
2
+
3
+ const { createError } = require('../errors');
4
+
5
+ const SVG_DANGER_RE = /<(?:script|foreignObject)\b|\bon\w+\s*=|javascript:|<\!ENTITY|<\!DOCTYPE|@import/i;
6
+
7
+ /**
8
+ * Checks SVG markup for dangerous active elements, scripts, and XML entity injections.
9
+ * Enforces Zero-Trust Vector Ingestion.
10
+ *
11
+ * @param {Uint8Array|Buffer|string} input - Raw SVG bytes or string
12
+ * @returns {{ safe: boolean, reason?: string, detail?: string }}
13
+ */
14
+ function checkSvgSafety(input) {
15
+ if (!input) {
16
+ return { safe: false, reason: 'Empty SVG input' };
17
+ }
18
+
19
+ let text;
20
+ if (typeof input === 'string') {
21
+ text = input;
22
+ } else if (Buffer.isBuffer(input)) {
23
+ text = input.toString('utf8');
24
+ } else if (input instanceof Uint8Array) {
25
+ text = Buffer.from(input.buffer, input.byteOffset, input.byteLength).toString('utf8');
26
+ } else {
27
+ return { safe: false, reason: 'Invalid SVG input format' };
28
+ }
29
+
30
+ const match = text.match(SVG_DANGER_RE);
31
+ if (match) {
32
+ return {
33
+ safe: false,
34
+ reason: 'E_UNSAFE_SVG',
35
+ detail: `SVG contains prohibited active or external pattern: "${match[0]}"`,
36
+ };
37
+ }
38
+
39
+ return { safe: true };
40
+ }
41
+
42
+ /**
43
+ * Validates SVG and throws a standardized ZapwebpError if unsafe.
44
+ *
45
+ * @param {Uint8Array|Buffer|string} input
46
+ * @param {{ allowUnsafe?: boolean }} [options]
47
+ * @throws {ZapwebpError}
48
+ */
49
+ function assertSvgSafety(input, options = {}) {
50
+ const check = checkSvgSafety(input);
51
+ if (!check.safe) {
52
+ if (options.allowUnsafe) {
53
+ if (typeof console !== 'undefined' && console.warn) {
54
+ console.warn(`[Zapwebp Warning]: ${check.detail || check.reason}`);
55
+ }
56
+ return;
57
+ }
58
+ throw createError('E_UNSAFE_SVG', check.detail || 'SVG contains active scripts or external references.');
59
+ }
60
+ }
61
+
62
+ module.exports = {
63
+ checkSvgSafety,
64
+ assertSvgSafety,
65
+ };
66
+