@godscene/core 1.7.11

package/dist/es/dump/screenshot-store.mjs

@@ -0,0 +1,125 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
+import { extractImageByIdSync } from "./html-utils.mjs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function normalizeScreenshotRef(value) {
+    if ('object' != typeof value || null === value) return null;
+    const record = value;
+    if ('midscene_screenshot_ref' === record.type && 'string' == typeof record.id && 'number' == typeof record.capturedAt && ('inline' === record.storage || 'file' === record.storage) && ('image/png' === record.mimeType || 'image/jpeg' === record.mimeType)) {
+        if ('file' === record.storage && 'string' != typeof record.path) return null;
+        return record;
+    }
+    return null;
+}
+function extensionByMimeType(mimeType) {
+    return 'image/jpeg' === mimeType ? 'jpeg' : 'png';
+}
+function resolveScreenshotSource(refInput, options) {
+    const ref = normalizeScreenshotRef(refInput);
+    const id = ref?.id ?? options.fallbackId;
+    const mimeType = ref?.mimeType ?? options.fallbackMimeType;
+    if (!id || !mimeType) throw new Error('ScreenshotStore: screenshot id and mimeType are required to resolve screenshot');
+    const resolveReportRelativePath = (filePath)=>isAbsolute(filePath) ? filePath : join(dirname(options.reportPath), filePath);
+    if (ref?.storage === 'file') {
+        if (!ref.path) throw new Error(`ScreenshotStore: screenshot ref "${ref.id}" missing file path`);
+        const explicitFilePath = resolveReportRelativePath(ref.path);
+        if (existsSync(explicitFilePath)) return {
+            type: 'file',
+            id,
+            mimeType,
+            filePath: explicitFilePath
+        };
+    }
+    const inlineDataUri = extractImageByIdSync(options.reportPath, id);
+    if (inlineDataUri) return {
+        type: 'data-uri',
+        id,
+        mimeType,
+        dataUri: inlineDataUri
+    };
+    const siblingScreenshotPath = join(dirname(options.reportPath), 'screenshots', `${id}.${extensionByMimeType(mimeType)}`);
+    if (existsSync(siblingScreenshotPath)) return {
+        type: 'file',
+        id,
+        mimeType,
+        filePath: siblingScreenshotPath
+    };
+    throw new Error(`ScreenshotStore: cannot resolve screenshot "${id}" from ${options.reportPath}`);
+}
+class ScreenshotStore {
+    async persist(screenshot) {
+        const shouldWriteFileCopy = 'directory' === this.mode || this.alsoWriteFileCopy;
+        const fileRef = shouldWriteFileCopy ? await this.persistToSharedFileIfNeeded(screenshot, {
+            markAsPersisted: 'directory' === this.mode
+        }) : null;
+        if ('inline' === this.mode) {
+            if (!this.writeInlineImage) throw new Error('ScreenshotStore: writeInlineImage is required in inline mode');
+            if (!this.writtenInlineIds.has(screenshot.id)) {
+                await this.writeInlineImage(screenshot.id, screenshot.base64);
+                this.writtenInlineIds.add(screenshot.id);
+            }
+            return screenshot.markPersistedInline(this.reportPath);
+        }
+        if (!fileRef) throw new Error('ScreenshotStore: file persistence is required in directory mode');
+        return fileRef;
+    }
+    async persistToSharedFileIfNeeded(screenshot, options) {
+        const screenshotsDir = this.screenshotsDir;
+        if (!screenshotsDir) throw new Error('ScreenshotStore: screenshotsDir is required when file persistence is enabled');
+        if (!existsSync(screenshotsDir)) mkdirSync(screenshotsDir, {
+            recursive: true
+        });
+        const relativePath = `./screenshots/${screenshot.id}.${screenshot.extension}`;
+        const absolutePath = join(screenshotsDir, `${screenshot.id}.${screenshot.extension}`);
+        if (!this.writtenFileIds.has(screenshot.id)) {
+            const buffer = Buffer.from(screenshot.rawBase64, 'base64');
+            await writeFile(absolutePath, buffer);
+            this.writtenFileIds.add(screenshot.id);
+        }
+        if (options.markAsPersisted) return screenshot.markPersistedToPath(relativePath, absolutePath);
+        return screenshot.registerPersistedFileCopy(relativePath, absolutePath);
+    }
+    loadBase64(refInput) {
+        const ref = normalizeScreenshotRef(refInput);
+        if (!ref) throw new Error('ScreenshotStore: invalid screenshot reference');
+        const resolved = resolveScreenshotSource(ref, {
+            reportPath: this.reportPath
+        });
+        if ('data-uri' === resolved.type) return resolved.dataUri;
+        const data = readFileSync(resolved.filePath);
+        return `data:${resolved.mimeType};base64,${data.toString('base64')}`;
+    }
+    cleanup() {
+        if ('directory' === this.mode && this.screenshotsDir && existsSync(this.screenshotsDir)) rmSync(this.screenshotsDir, {
+            recursive: true,
+            force: true
+        });
+        this.writtenInlineIds.clear();
+        this.writtenFileIds.clear();
+    }
+    constructor(options){
+        _define_property(this, "mode", void 0);
+        _define_property(this, "reportPath", void 0);
+        _define_property(this, "screenshotsDir", void 0);
+        _define_property(this, "writeInlineImage", void 0);
+        _define_property(this, "alsoWriteFileCopy", void 0);
+        _define_property(this, "writtenInlineIds", new Set());
+        _define_property(this, "writtenFileIds", new Set());
+        this.mode = options.mode;
+        this.reportPath = options.reportPath;
+        this.screenshotsDir = options.screenshotsDir;
+        this.writeInlineImage = options.writeInlineImage;
+        this.alsoWriteFileCopy = options.alsoWriteFileCopy ?? options.ensureFileCopy ?? false;
+    }
+}
+export { ScreenshotStore, normalizeScreenshotRef, resolveScreenshotSource };

package/dist/es/index.mjs

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import service from "./service/index.mjs";
+import { TaskRunner } from "./task-runner.mjs";
+import { getVersion } from "./utils.mjs";
+import { AiLocateElement, PointSchema, RectSchema, SizeSchema, TMultimodalPromptSchema, TUserPromptSchema, getMidsceneLocationSchema, plan, runConnectivityTest } from "./ai-model/index.mjs";
+import { MIDSCENE_MODEL_NAME } from "@godscene/shared/env";
+import { ExecutionDump, GroupedActionDump, ReportActionDump, ServiceError } from "./types.mjs";
+import { Agent, createAgent } from "./agent/index.mjs";
+import { escapeContent, generateDumpScriptTag, generateImageScriptTag, parseDumpScript, parseDumpScriptAttributes, parseImageScripts, restoreImageReferences, unescapeContent } from "./dump/index.mjs";
+import { ReportGenerator, nullReportGenerator } from "./report-generator.mjs";
+import { ReportMergingTool, collectDedupedExecutions, dedupeExecutionsKeepLatest, splitReportHtmlByExecution } from "./report.mjs";
+import { createReportCliCommands, reportFileToMarkdown, splitReportFile } from "./report-cli.mjs";
+import { ScreenshotItem } from "./screenshot-item.mjs";
+import { ScreenshotStore } from "./dump/screenshot-store.mjs";
+import { executionToMarkdown, reportToMarkdown } from "./report-markdown.mjs";
+const src = service;
+export { Agent, AiLocateElement, ExecutionDump, GroupedActionDump, MIDSCENE_MODEL_NAME, PointSchema, RectSchema, ReportActionDump, ReportGenerator, ReportMergingTool, ScreenshotItem, ScreenshotStore, service as Service, ServiceError, SizeSchema, TMultimodalPromptSchema, TUserPromptSchema, TaskRunner, collectDedupedExecutions, createAgent, createReportCliCommands, dedupeExecutionsKeepLatest, src as default, escapeContent, executionToMarkdown, generateDumpScriptTag, generateImageScriptTag, getMidsceneLocationSchema, getVersion, nullReportGenerator, parseDumpScript, parseDumpScriptAttributes, parseImageScripts, plan, reportFileToMarkdown, reportToMarkdown, restoreImageReferences, runConnectivityTest, splitReportFile, splitReportHtmlByExecution, unescapeContent, z };

package/dist/es/report-cli.mjs

@@ -0,0 +1,149 @@
+import { copyFileSync, existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { z } from "zod";
+import { resolveScreenshotSource } from "./dump/screenshot-store.mjs";
+import { collectDedupedExecutions, splitReportHtmlByExecution } from "./report.mjs";
+import { reportToMarkdown } from "./report-markdown.mjs";
+import { ReportActionDump } from "./types.mjs";
+function writeAttachmentFromReport(attachment, opts) {
+    const { suggestedFileName, id, mimeType } = attachment;
+    if (opts.writtenFiles.has(suggestedFileName)) return;
+    const absolutePath = join(opts.screenshotsDir, suggestedFileName);
+    const outputRelativePath = `./screenshots/${suggestedFileName}`;
+    const sourceRef = attachment.filePath !== outputRelativePath ? {
+        type: 'midscene_screenshot_ref',
+        id,
+        capturedAt: 0,
+        mimeType: mimeType || 'image/png',
+        storage: 'file',
+        path: attachment.filePath
+    } : null;
+    const resolved = resolveScreenshotSource(sourceRef, {
+        reportPath: opts.htmlPath,
+        fallbackId: id,
+        fallbackMimeType: mimeType || 'image/png'
+    });
+    if ('data-uri' === resolved.type) {
+        const rawBase64 = resolved.dataUri.replace(/^data:image\/[a-zA-Z+]+;base64,/, '');
+        writeFileSync(absolutePath, Buffer.from(rawBase64, 'base64'));
+        opts.writtenFiles.add(suggestedFileName);
+        return;
+    }
+    if (!existsSync(resolved.filePath)) throw new Error(`Cannot resolve screenshot "${id}" for markdown attachment from ${opts.htmlPath}`);
+    copyFileSync(resolved.filePath, absolutePath);
+    opts.writtenFiles.add(suggestedFileName);
+}
+async function markdownFromReport(htmlPath, outputDir) {
+    const screenshotsDir = join(outputDir, 'screenshots');
+    mkdirSync(outputDir, {
+        recursive: true
+    });
+    mkdirSync(screenshotsDir, {
+        recursive: true
+    });
+    const { baseDump, executions } = collectDedupedExecutions(htmlPath);
+    const mergedReport = new ReportActionDump({
+        sdkVersion: baseDump.sdkVersion,
+        groupName: baseDump.groupName,
+        groupDescription: baseDump.groupDescription,
+        modelBriefs: baseDump.modelBriefs,
+        deviceType: baseDump.deviceType,
+        executions
+    });
+    const result = reportToMarkdown(mergedReport);
+    const markdownFiles = [];
+    const writtenScreenshots = new Set();
+    const mdPath = join(outputDir, 'report.md');
+    writeFileSync(mdPath, result.markdown, 'utf-8');
+    markdownFiles.push(mdPath);
+    for (const attachment of result.attachments)writeAttachmentFromReport(attachment, {
+        htmlPath,
+        screenshotsDir,
+        writtenFiles: writtenScreenshots
+    });
+    return {
+        markdownFiles,
+        screenshotFiles: Array.from(writtenScreenshots).sort().map((f)=>join(screenshotsDir, f))
+    };
+}
+function resolveReportHtmlPath(htmlPath) {
+    const normalizedPath = resolve(htmlPath);
+    if (!existsSync(normalizedPath)) throw new Error(`report-tool: --htmlPath does not exist: ${htmlPath}`);
+    const stats = statSync(normalizedPath);
+    if (!stats.isDirectory()) return normalizedPath;
+    const indexHtmlPath = join(normalizedPath, 'index.html');
+    if (!existsSync(indexHtmlPath)) throw new Error(`report-tool: "${htmlPath}" is not an HTML report file, and no index.html was found under this directory.`);
+    return indexHtmlPath;
+}
+function splitReportFile(options) {
+    const { htmlPath, outputDir } = options;
+    if (!htmlPath) throw new Error('splitReportFile: htmlPath is required');
+    if (!outputDir) throw new Error('splitReportFile: outputDir is required');
+    const resolvedHtmlPath = resolveReportHtmlPath(htmlPath);
+    return splitReportHtmlByExecution({
+        htmlPath: resolvedHtmlPath,
+        outputDir
+    });
+}
+async function reportFileToMarkdown(options) {
+    const { htmlPath, outputDir } = options;
+    if (!htmlPath) throw new Error('reportFileToMarkdown: htmlPath is required');
+    if (!outputDir) throw new Error('reportFileToMarkdown: outputDir is required');
+    const resolvedHtmlPath = resolveReportHtmlPath(htmlPath);
+    return markdownFromReport(resolvedHtmlPath, outputDir);
+}
+const reportCommandDefinition = {
+    name: 'report-tool',
+    description: 'Transform Midscene report artifacts, including splitting executions and converting to markdown.',
+    schema: {
+        action: z["enum"]([
+            'split',
+            'to-markdown'
+        ]).optional().describe('Report action to run. Supports: split, to-markdown. Defaults to split.'),
+        htmlPath: z.string().optional().describe('Input report HTML path (e.g. ./report/index.html)'),
+        outputDir: z.string().optional().describe('Output directory for generated report artifacts')
+    },
+    handler: async (args)=>{
+        const { action = 'split', htmlPath, outputDir } = args;
+        if ('split' !== action && 'to-markdown' !== action) throw new Error(`report-tool: unsupported --action value "${action}". Currently supported: split, to-markdown`);
+        if (!htmlPath) throw new Error('report-tool: --htmlPath is required');
+        if (!outputDir) throw new Error('report-tool: --outputDir is required');
+        if ('to-markdown' === action) {
+            const result = await reportFileToMarkdown({
+                htmlPath,
+                outputDir
+            });
+            return {
+                isError: false,
+                content: [
+                    {
+                        type: 'text',
+                        text: `Markdown export completed. Generated ${result.markdownFiles.length} markdown file(s) and ${result.screenshotFiles.length} screenshot(s). Output path: ${outputDir}`
+                    }
+                ]
+            };
+        }
+        const result = splitReportFile({
+            htmlPath,
+            outputDir
+        });
+        return {
+            isError: false,
+            content: [
+                {
+                    type: 'text',
+                    text: `Report split completed. Generated ${result.executionJsonFiles.length} execution JSON files and ${result.screenshotFiles.length} screenshots. Output path: ${outputDir}`
+                }
+            ]
+        };
+    }
+};
+function createReportCliCommands() {
+    return [
+        {
+            name: 'report-tool',
+            def: reportCommandDefinition
+        }
+    ];
+}
+export { createReportCliCommands, reportFileToMarkdown, splitReportFile };

package/dist/es/report-generator.mjs

@@ -0,0 +1,203 @@
+import { existsSync, mkdirSync, readdirSync } from "node:fs";
+import { appendFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getMidsceneRunSubDir } from "@godscene/shared/common";
+import { MIDSCENE_REPORT_QUIET, globalConfigManager } from "@godscene/shared/env";
+import { ifInBrowser, logMsg, uuid } from "@godscene/shared/utils";
+import { generateDumpScriptTag, generateImageScriptTag, getBaseUrlFixScript } from "./dump/html-utils.mjs";
+import { ScreenshotStore } from "./dump/screenshot-store.mjs";
+import { ReportActionDump } from "./types.mjs";
+import { getReportTpl } from "./utils.mjs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const nullReportGenerator = {
+    onExecutionUpdate: ()=>{},
+    flush: async ()=>{},
+    finalize: async ()=>void 0,
+    getReportPath: ()=>void 0
+};
+function assertReportGenerationOptions(opts) {
+    if (false === opts.generateReport && true === opts.persistExecutionDump) throw new Error('persistExecutionDump cannot be true when generateReport is false');
+}
+class ReportGenerator {
+    static create(reportFileName, opts) {
+        assertReportGenerationOptions(opts);
+        if (false === opts.generateReport) return nullReportGenerator;
+        if (ifInBrowser) return nullReportGenerator;
+        validateReportFileName(reportFileName);
+        const reportRootDir = getMidsceneRunSubDir('report');
+        const outputDir = join(reportRootDir, reportFileName);
+        const reportPath = 'html-and-external-assets' === opts.outputFormat ? join(outputDir, 'index.html') : join(reportRootDir, ensureHtmlFileName(reportFileName));
+        return new ReportGenerator({
+            reportPath,
+            screenshotMode: 'html-and-external-assets' === opts.outputFormat ? 'directory' : 'inline',
+            persistExecutionDump: opts.persistExecutionDump,
+            autoPrint: opts.autoPrintReportMsg,
+            reuseExistingReport: opts.reuseExistingReport
+        });
+    }
+    onExecutionUpdate(execution, reportMeta, attributes) {
+        this.lastExecution = execution;
+        this.lastReportMeta = reportMeta;
+        this.mergeReportAttributes(attributes);
+        this.writeQueue = this.writeQueue.then(async ()=>{
+            if (this.destroyed) return;
+            await this.doWriteExecution(execution, reportMeta);
+        });
+    }
+    async flush() {
+        await this.writeQueue;
+    }
+    async finalize() {
+        if (this.lastExecution && this.lastReportMeta) this.onExecutionUpdate(this.lastExecution, this.lastReportMeta);
+        await this.flush();
+        this.destroyed = true;
+        if (!this.initialized) return;
+        this.printReportPath('finalized');
+        return this.reportPath;
+    }
+    getReportPath() {
+        return this.reportPath;
+    }
+    printReportPath(verb) {
+        if (!this.autoPrint || !this.reportPath) return;
+        if (globalConfigManager.getEnvConfigInBoolean(MIDSCENE_REPORT_QUIET)) return;
+        'directory' === this.screenshotMode ? logMsg(`Midscene - report ${verb}: npx serve ${dirname(this.reportPath)}`) : logMsg(`Midscene - report ${verb}: ${this.reportPath}`);
+    }
+    async doWriteExecution(execution, reportMeta) {
+        const singleDump = this.wrapAsReportDump(execution, reportMeta);
+        if ('inline' === this.screenshotMode) await this.writeInlineExecution(execution, singleDump);
+        else await this.writeDirectoryExecution(execution, singleDump);
+        if (this.shouldPersistExecutionDump) await this.persistExecutionDumpToFile(execution, singleDump);
+        if (!this.firstWriteDone) {
+            this.firstWriteDone = true;
+            this.printReportPath('generated');
+        }
+    }
+    mergeReportAttributes(attributes) {
+        if (!attributes) return;
+        for (const [key, value] of Object.entries(attributes))if (null != value) this.reportAttributes[key] = String(value);
+    }
+    hydrateStateFromExistingReport() {
+        if (!existsSync(this.reportPath)) return;
+        this.initialized = true;
+        if (!this.shouldPersistExecutionDump) return;
+        const reportDir = dirname(this.reportPath);
+        const existingExecutionIndices = readdirSync(reportDir).map((name)=>/^(\d+)\.execution\.json$/.exec(name)?.[1]).filter((index)=>Boolean(index)).map((index)=>Number.parseInt(index, 10)).filter((index)=>Number.isFinite(index));
+        if (existingExecutionIndices.length > 0) this.executionLogIndex = Math.max(...existingExecutionIndices);
+    }
+    getDumpScriptAttributes() {
+        return {
+            'data-group-id': this.reportStreamId,
+            ...this.reportAttributes
+        };
+    }
+    wrapAsReportDump(execution, reportMeta) {
+        return new ReportActionDump({
+            sdkVersion: reportMeta.sdkVersion,
+            groupName: reportMeta.groupName,
+            groupDescription: reportMeta.groupDescription,
+            modelBriefs: reportMeta.modelBriefs,
+            deviceType: reportMeta.deviceType,
+            executions: [
+                execution
+            ]
+        });
+    }
+    async writeInlineExecution(execution, singleDump) {
+        const dir = dirname(this.reportPath);
+        if (!existsSync(dir)) mkdirSync(dir, {
+            recursive: true
+        });
+        if (!this.initialized) {
+            await writeFile(this.reportPath, getReportTpl());
+            this.initialized = true;
+        }
+        for (const screenshot of execution.collectScreenshots())await this.screenshotStore.persist(screenshot);
+        const serialized = singleDump.serialize();
+        await appendFile(this.reportPath, `\n${generateDumpScriptTag(serialized, this.getDumpScriptAttributes())}`);
+    }
+    async writeDirectoryExecution(execution, singleDump) {
+        const dir = dirname(this.reportPath);
+        if (!existsSync(dir)) mkdirSync(dir, {
+            recursive: true
+        });
+        for (const screenshot of execution.collectScreenshots())await this.screenshotStore.persist(screenshot);
+        const serialized = singleDump.serialize();
+        if (!this.initialized) {
+            await writeFile(this.reportPath, `${getReportTpl()}${getBaseUrlFixScript()}`);
+            this.initialized = true;
+        }
+        await appendFile(this.reportPath, `\n${generateDumpScriptTag(serialized, this.getDumpScriptAttributes())}`);
+    }
+    getExecutionLogKey(execution) {
+        if (!execution.id) throw new Error('ReportGenerator: execution.id is required for persisting execution dumps');
+        return `id:${execution.id}`;
+    }
+    async persistExecutionDumpToFile(execution, singleDump) {
+        const dir = dirname(this.reportPath);
+        if (!existsSync(dir)) mkdirSync(dir, {
+            recursive: true
+        });
+        const executionLogKey = this.getExecutionLogKey(execution);
+        let fileIndex = this.executionLogFileIndexByExecutionKey.get(executionLogKey);
+        if (!fileIndex) {
+            this.executionLogIndex += 1;
+            fileIndex = this.executionLogIndex;
+            this.executionLogFileIndexByExecutionKey.set(executionLogKey, fileIndex);
+        }
+        const fileName = `${fileIndex}.execution.json`;
+        const filePath = join(dirname(this.reportPath), fileName);
+        await writeFile(filePath, singleDump.serialize(2), 'utf-8');
+    }
+    constructor(options){
+        _define_property(this, "reportPath", void 0);
+        _define_property(this, "screenshotMode", void 0);
+        _define_property(this, "shouldPersistExecutionDump", void 0);
+        _define_property(this, "autoPrint", void 0);
+        _define_property(this, "firstWriteDone", false);
+        _define_property(this, "executionLogIndex", 0);
+        _define_property(this, "executionLogFileIndexByExecutionKey", new Map());
+        _define_property(this, "reportStreamId", void 0);
+        _define_property(this, "screenshotStore", void 0);
+        _define_property(this, "initialized", false);
+        _define_property(this, "lastExecution", void 0);
+        _define_property(this, "lastReportMeta", void 0);
+        _define_property(this, "reportAttributes", {});
+        _define_property(this, "writeQueue", Promise.resolve());
+        _define_property(this, "destroyed", false);
+        this.reportPath = options.reportPath;
+        this.screenshotMode = options.screenshotMode;
+        this.shouldPersistExecutionDump = options.persistExecutionDump ?? false;
+        this.autoPrint = options.autoPrint ?? true;
+        this.reportStreamId = uuid();
+        this.screenshotStore = new ScreenshotStore({
+            mode: 'inline' === this.screenshotMode ? 'inline' : 'directory',
+            reportPath: this.reportPath,
+            screenshotsDir: join(dirname(this.reportPath), 'screenshots'),
+            writeInlineImage: async (id, base64)=>{
+                await appendFile(this.reportPath, `\n${generateImageScriptTag(id, base64)}`);
+            },
+            alsoWriteFileCopy: this.shouldPersistExecutionDump
+        });
+        if (options.reuseExistingReport) this.hydrateStateFromExistingReport();
+        this.printReportPath('will be generated at');
+    }
+}
+function ensureHtmlFileName(reportFileName) {
+    return reportFileName.endsWith('.html') ? reportFileName : `${reportFileName}.html`;
+}
+function validateReportFileName(reportFileName) {
+    if (!reportFileName?.trim()) throw new Error('reportFileName must be a non-empty string');
+    if (/[\\/]/.test(reportFileName)) throw new Error('reportFileName must not contain path separators (`/` or `\\\\`)');
+    if (/[:*?"<>|]/.test(reportFileName)) throw new Error('reportFileName contains illegal filename characters: : * ? " < > |');
+}
+export { ReportGenerator, assertReportGenerationOptions, nullReportGenerator };