@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Output/ArtifactTransformer/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DotCliArtifactTransformer.js"), exports);

package/dist/cjs/Output/ArtifactTransformer.d.ts

@@ -0,0 +1,7 @@
+import { RenderArtifact } from '../Graph/Renderer.js';
+export type ArtifactTransformInput = {
+    artifact: RenderArtifact;
+};
+export interface ArtifactTransformer {
+    transform(input: ArtifactTransformInput): Promise<RenderArtifact>;
+}

package/dist/cjs/Output/ArtifactTransformer.js

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

package/dist/cjs/Output/ArtifactTransformerFactory/DefaultArtifactTransformerFactory.d.ts

@@ -0,0 +1,17 @@
+import { ArtifactTransformer } from '../ArtifactTransformer.js';
+import { DotCliRunProcess } from '../ArtifactTransformer/DotCliArtifactTransformer.js';
+import { ArtifactTransformerFactory, ArtifactTransformerFactoryInput } from '../ArtifactTransformerFactory.js';
+export type DefaultArtifactTransformerFactoryOptions = {
+    dotCliRunProcess?: DotCliRunProcess;
+};
+export declare class DefaultArtifactTransformerFactory implements ArtifactTransformerFactory {
+    private readonly options;
+    constructor(options?: DefaultArtifactTransformerFactoryOptions);
+    create(input: ArtifactTransformerFactoryInput): ArtifactTransformer;
+    private createDotCliTransformer;
+    private resolveDotArgs;
+    private readRequiredStringOption;
+    private readOptionalStringOption;
+    private readStringListOption;
+    private toStringList;
+}

package/dist/cjs/Output/ArtifactTransformerFactory/DefaultArtifactTransformerFactory.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultArtifactTransformerFactory = void 0;
+const DotCliArtifactTransformer_js_1 = require("../ArtifactTransformer/DotCliArtifactTransformer.js");
+class DefaultArtifactTransformerFactory {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    create(input) {
+        const transformerName = input.name.trim().toLowerCase();
+        if (transformerName === 'dotcli') {
+            return this.createDotCliTransformer(input.options);
+        }
+        throw new Error(`Unsupported transformer '${input.name}'`);
+    }
+    createDotCliTransformer(options) {
+        const format = this.readRequiredStringOption('dotcli', 'format', options);
+        const executable = this.readOptionalStringOption('executable', options);
+        const dotArgs = this.resolveDotArgs(options);
+        return new DotCliArtifactTransformer_js_1.DotCliArtifactTransformer({
+            format,
+            executable,
+            dotArgs: dotArgs.length > 0 ? dotArgs : undefined,
+            runProcess: this.options.dotCliRunProcess,
+        });
+    }
+    resolveDotArgs(options) {
+        if (!options) {
+            return [];
+        }
+        const dotArgs = [
+            ...this.readStringListOption('dotArg', options),
+            ...this.readStringListOption('dotArgs', options),
+            ...this.readStringListOption('arg', options),
+            ...this.readStringListOption('args', options),
+        ];
+        for (const [key, value] of Object.entries(options)) {
+            if (key === 'format' ||
+                key === 'executable' ||
+                key === 'dotArg' ||
+                key === 'dotArgs' ||
+                key === 'arg' ||
+                key === 'args') {
+                continue;
+            }
+            for (const item of this.toStringList(value)) {
+                dotArgs.push(`-${key}=${item}`);
+            }
+        }
+        return dotArgs;
+    }
+    readRequiredStringOption(transformerName, optionName, options) {
+        const value = this.readOptionalStringOption(optionName, options);
+        if (!value) {
+            throw new Error(`Transformer '${transformerName}' requires option '${optionName}'`);
+        }
+        return value;
+    }
+    readOptionalStringOption(optionName, options) {
+        const value = options?.[optionName];
+        if (value === undefined) {
+            return undefined;
+        }
+        return this.toStringList(value)[0];
+    }
+    readStringListOption(optionName, options) {
+        const value = options?.[optionName];
+        if (value === undefined) {
+            return [];
+        }
+        return this.toStringList(value);
+    }
+    toStringList(value) {
+        return Array.isArray(value) ? [...value] : [value];
+    }
+}
+exports.DefaultArtifactTransformerFactory = DefaultArtifactTransformerFactory;

package/dist/cjs/Output/ArtifactTransformerFactory/DefaultArtifactTransformerFactory.test.d.ts

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

package/dist/cjs/Output/ArtifactTransformerFactory/DefaultArtifactTransformerFactory.test.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DefaultArtifactTransformerFactory_js_1 = require("./DefaultArtifactTransformerFactory.js");
+describe('DefaultArtifactTransformerFactory.create', () => {
+    it('shoud create dotcli transformer with mapped options', async () => {
+        const calls = [];
+        const factory = new DefaultArtifactTransformerFactory_js_1.DefaultArtifactTransformerFactory({
+            dotCliRunProcess: async (input) => {
+                calls.push(input);
+                return Buffer.from([1, 2, 3]);
+            },
+        });
+        const transformer = factory.create({
+            name: 'dotcli',
+            options: {
+                format: 'png',
+                executable: 'dot-custom',
+                dotArg: ['-Nshape=box', '-Ecolor=red'],
+                Gdpi: '200',
+            },
+        });
+        await transformer.transform({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+                extension: 'dot',
+            },
+        });
+        expect(calls).toHaveLength(1);
+        expect(calls[0]).toEqual({
+            executable: 'dot-custom',
+            args: ['-Tpng', '-Nshape=box', '-Ecolor=red', '-Gdpi=200'],
+            stdin: 'digraph G {}',
+        });
+    });
+    it('shoud throw when transformer is not supported', () => {
+        const factory = new DefaultArtifactTransformerFactory_js_1.DefaultArtifactTransformerFactory();
+        expect(() => factory.create({
+            name: 'unknown',
+        })).toThrow("Unsupported transformer 'unknown'");
+    });
+    it('shoud require format for dotcli', () => {
+        const factory = new DefaultArtifactTransformerFactory_js_1.DefaultArtifactTransformerFactory();
+        expect(() => factory.create({
+            name: 'dotcli',
+        })).toThrow("Transformer 'dotcli' requires option 'format'");
+    });
+    it('shoud default to dot executable when none is provided', async () => {
+        const calls = [];
+        const factory = new DefaultArtifactTransformerFactory_js_1.DefaultArtifactTransformerFactory({
+            dotCliRunProcess: async (input) => {
+                calls.push(input);
+                return Buffer.from([4, 5, 6]);
+            },
+        });
+        const transformer = factory.create({
+            name: 'dotcli',
+            options: {
+                format: 'svg',
+            },
+        });
+        await transformer.transform({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+                extension: 'dot',
+            },
+        });
+        expect(calls[0]).toEqual({
+            executable: 'dot',
+            args: ['-Tsvg'],
+            stdin: 'digraph G {}',
+        });
+    });
+    it('shoud return empty dot args when options are undefined', () => {
+        const factory = new DefaultArtifactTransformerFactory_js_1.DefaultArtifactTransformerFactory();
+        const resolver = factory;
+        expect(resolver.resolveDotArgs()).toEqual([]);
+    });
+});

package/dist/cjs/Output/ArtifactTransformerFactory/OclifTransformerFlagParser.d.ts

@@ -0,0 +1,9 @@
+import { ArtifactTransformerOptions } from '../ArtifactTransformerFactory.js';
+export type TransformerFlagOptions = Record<string, ArtifactTransformerOptions>;
+export declare class OclifTransformerFlagParser {
+    stripOptionFlags(argv: string[]): string[];
+    parse(argv: string[]): TransformerFlagOptions;
+    private isTransformerOptionFlag;
+    private addOption;
+    private mergeOptionValues;
+}

package/dist/cjs/Output/ArtifactTransformerFactory/OclifTransformerFlagParser.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OclifTransformerFlagParser = void 0;
+class OclifTransformerFlagParser {
+    stripOptionFlags(argv) {
+        const stripped = [];
+        for (let index = 0; index < argv.length; index += 1) {
+            const token = argv[index];
+            if (!this.isTransformerOptionFlag(token)) {
+                stripped.push(token);
+                continue;
+            }
+            const equalsIndex = token.indexOf('=');
+            if (equalsIndex < 0 &&
+                index + 1 < argv.length &&
+                !argv[index + 1].startsWith('--')) {
+                index += 1;
+            }
+        }
+        return stripped;
+    }
+    parse(argv) {
+        const options = {};
+        for (let index = 0; index < argv.length; index += 1) {
+            const token = argv[index];
+            if (!token.startsWith('--transformer-')) {
+                continue;
+            }
+            if (token === '--transformer' || token.startsWith('--transformer=')) {
+                continue;
+            }
+            const equalsIndex = token.indexOf('=');
+            const flag = equalsIndex >= 0 ? token.slice(0, equalsIndex) : token;
+            const match = /^--transformer-([A-Za-z0-9_-]+)-([A-Za-z0-9_-]+)$/.exec(flag);
+            if (!match) {
+                continue;
+            }
+            let value = equalsIndex >= 0 ? token.slice(equalsIndex + 1) : undefined;
+            if (value === undefined &&
+                index + 1 < argv.length &&
+                !argv[index + 1].startsWith('--')) {
+                value = argv[index + 1];
+                index += 1;
+            }
+            const [, transformerName, optionName] = match;
+            this.addOption(options, transformerName, optionName, value ?? 'true');
+        }
+        return options;
+    }
+    isTransformerOptionFlag(token) {
+        if (!token.startsWith('--transformer-')) {
+            return false;
+        }
+        if (token === '--transformer' || token.startsWith('--transformer=')) {
+            return false;
+        }
+        const equalsIndex = token.indexOf('=');
+        const flag = equalsIndex >= 0 ? token.slice(0, equalsIndex) : token;
+        return /^--transformer-([A-Za-z0-9_-]+)-([A-Za-z0-9_-]+)$/.test(flag);
+    }
+    addOption(options, transformerName, optionName, optionValue) {
+        if (!options[transformerName]) {
+            options[transformerName] = {};
+        }
+        const transformerOptions = options[transformerName];
+        const current = transformerOptions[optionName];
+        if (current === undefined) {
+            transformerOptions[optionName] = optionValue;
+            return;
+        }
+        transformerOptions[optionName] = this.mergeOptionValues(current, optionValue);
+    }
+    mergeOptionValues(current, next) {
+        if (Array.isArray(current)) {
+            return [...current, next];
+        }
+        return [current, next];
+    }
+}
+exports.OclifTransformerFlagParser = OclifTransformerFlagParser;

package/dist/cjs/Output/ArtifactTransformerFactory/OclifTransformerFlagParser.test.d.ts

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

package/dist/cjs/Output/ArtifactTransformerFactory/OclifTransformerFlagParser.test.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const OclifTransformerFlagParser_js_1 = require("./OclifTransformerFlagParser.js");
+describe('OclifTransformerFlagParser.parse', () => {
+    it('shoud parse transformer option flags using equals syntax', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const options = parser.parse([
+            '--transformer=dotcli',
+            '--transformer-dotcli-format=png',
+            '--transformer-dotcli-dotArg=-Gdpi=200',
+        ]);
+        expect(options).toEqual({
+            dotcli: {
+                format: 'png',
+                dotArg: '-Gdpi=200',
+            },
+        });
+    });
+    it('shoud parse transformer option flags using spaced values', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const options = parser.parse([
+            '--transformer',
+            'dotcli',
+            '--transformer-dotcli-format',
+            'svg',
+            '--transformer-dotcli-verbose',
+        ]);
+        expect(options).toEqual({
+            dotcli: {
+                format: 'svg',
+                verbose: 'true',
+            },
+        });
+    });
+    it('shoud accumulate repeated option values', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const options = parser.parse([
+            '--transformer-dotcli-dotArg=-Nshape=box',
+            '--transformer-dotcli-dotArg=-Ecolor=red',
+        ]);
+        expect(options).toEqual({
+            dotcli: {
+                dotArg: ['-Nshape=box', '-Ecolor=red'],
+            },
+        });
+    });
+    it('shoud treat missing values as true when followed by another flag', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const options = parser.parse(['--transformer-dotcli-format', '--verbose']);
+        expect(options).toEqual({
+            dotcli: {
+                format: 'true',
+            },
+        });
+    });
+    it('shoud skip non-transformer tokens and plain transformer flags', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const options = parser.parse([
+            '--profile=edf.aws.dot',
+            '--transformer',
+            'dotcli',
+            '--transformer-dotcli-format=png',
+        ]);
+        expect(options).toEqual({
+            dotcli: {
+                format: 'png',
+            },
+        });
+    });
+    it('shoud ignore transformer base flags even when prefix checks pass', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const trickyToken = {
+            startsWith: (value) => value === '--transformer-' || value === '--transformer=',
+        };
+        const options = parser.parse([
+            trickyToken,
+            '--transformer-dotcli-format=png',
+        ]);
+        expect(options).toEqual({
+            dotcli: {
+                format: 'png',
+            },
+        });
+    });
+    it('shoud ignore invalid transformer option flags', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const options = parser.parse(['--transformer-dotcli']);
+        expect(options).toEqual({});
+    });
+    it('shoud append repeated option values once already an array', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const options = parser.parse([
+            '--transformer-dotcli-dotArg=-a',
+            '--transformer-dotcli-dotArg=-b',
+            '--transformer-dotcli-dotArg=-c',
+        ]);
+        expect(options).toEqual({
+            dotcli: {
+                dotArg: ['-a', '-b', '-c'],
+            },
+        });
+    });
+    it('shoud validate transformer option flags directly', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const checker = parser;
+        expect(checker.isTransformerOptionFlag('--transformer-dotcli-format=png')).toBe(true);
+        expect(checker.isTransformerOptionFlag('--transformer-dotcli-format')).toBe(true);
+        expect(checker.isTransformerOptionFlag('--profile=edf.aws.dot')).toBe(false);
+        const trickyToken = {
+            startsWith: (value) => value === '--transformer-' || value === '--transformer=',
+        };
+        expect(checker.isTransformerOptionFlag(trickyToken)).toBe(false);
+        expect(checker.isTransformerOptionFlag('--transformer')).toBe(false);
+        expect(checker.isTransformerOptionFlag('--transformer=dotcli')).toBe(false);
+    });
+});
+describe('OclifTransformerFlagParser.stripOptionFlags', () => {
+    it('shoud remove transformer option flags while keeping declared flags', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const stripped = parser.stripOptionFlags([
+            '--profile=edf.aws.dot',
+            '--transformer=dotcli',
+            '--transformer-dotcli-format=png',
+            '--transformer-dotcli-dotArg',
+            '-Gdpi=200',
+            '--verbose',
+        ]);
+        expect(stripped).toEqual([
+            '--profile=edf.aws.dot',
+            '--transformer=dotcli',
+            '--verbose',
+        ]);
+    });
+    it('shoud keep non-matching flags that share the prefix', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const stripped = parser.stripOptionFlags([
+            '--transformer-dotcli',
+            '--transformer-dotcli-format=png',
+            '--transformer',
+            'dotcli',
+        ]);
+        expect(stripped).toEqual([
+            '--transformer-dotcli',
+            '--transformer',
+            'dotcli',
+        ]);
+    });
+    it('shoud not consume the next flag when a value is missing', () => {
+        const parser = new OclifTransformerFlagParser_js_1.OclifTransformerFlagParser();
+        const stripped = parser.stripOptionFlags([
+            '--transformer-dotcli-format',
+            '--verbose',
+        ]);
+        expect(stripped).toEqual(['--verbose']);
+    });
+});

package/dist/cjs/Output/ArtifactTransformerFactory/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DefaultArtifactTransformerFactory.js';
+export * from './OclifTransformerFlagParser.js';

package/dist/cjs/Output/ArtifactTransformerFactory/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DefaultArtifactTransformerFactory.js"), exports);
+__exportStar(require("./OclifTransformerFlagParser.js"), exports);

package/dist/cjs/Output/ArtifactTransformerFactory.d.ts

@@ -0,0 +1,10 @@
+import { ArtifactTransformer } from './ArtifactTransformer.js';
+export type ArtifactTransformerOptionValue = string | string[];
+export type ArtifactTransformerOptions = Record<string, ArtifactTransformerOptionValue>;
+export type ArtifactTransformerFactoryInput = {
+    name: string;
+    options?: ArtifactTransformerOptions;
+};
+export interface ArtifactTransformerFactory {
+    create(input: ArtifactTransformerFactoryInput): ArtifactTransformer;
+}

package/dist/cjs/Output/ArtifactTransformerFactory.js

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

package/dist/cjs/Output/ArtifactWriter/FileArtifactWriter.d.ts

@@ -0,0 +1,9 @@
+import { ArtifactWriteInput, ArtifactWriter } from '../ArtifactWriter.js';
+export type FileArtifactWriterOptions = {
+    createDirectories?: boolean;
+};
+export declare class FileArtifactWriter implements ArtifactWriter {
+    private readonly createDirectories;
+    constructor(options?: FileArtifactWriterOptions);
+    write(input: ArtifactWriteInput): Promise<void>;
+}

package/dist/cjs/Output/ArtifactWriter/FileArtifactWriter.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileArtifactWriter = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+class FileArtifactWriter {
+    createDirectories;
+    constructor(options = {}) {
+        this.createDirectories = options.createDirectories ?? true;
+    }
+    async write(input) {
+        if (!input.target) {
+            throw new Error('FileArtifactWriter requires a target path');
+        }
+        if (this.createDirectories) {
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(input.target), { recursive: true });
+        }
+        if (typeof input.artifact.content === 'string') {
+            await (0, promises_1.writeFile)(input.target, input.artifact.content, 'utf8');
+            return;
+        }
+        await (0, promises_1.writeFile)(input.target, Buffer.from(input.artifact.content));
+    }
+}
+exports.FileArtifactWriter = FileArtifactWriter;

package/dist/cjs/Output/ArtifactWriter/FileArtifactWriter.test.d.ts

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

package/dist/cjs/Output/ArtifactWriter/FileArtifactWriter.test.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const FileArtifactWriter_js_1 = require("./FileArtifactWriter.js");
+describe('FileArtifactWriter.write', () => {
+    it('shoud write string content to target path', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'file-artifact-writer-'));
+        const target = (0, node_path_1.join)(dir, 'nested', 'graph.dot');
+        const writer = new FileArtifactWriter_js_1.FileArtifactWriter();
+        try {
+            await writer.write({
+                target,
+                artifact: {
+                    content: 'digraph G {}',
+                    mediaType: 'text/vnd.graphviz',
+                    extension: 'dot',
+                },
+            });
+            const written = await (0, promises_1.readFile)(target, 'utf8');
+            expect(written).toBe('digraph G {}');
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud write binary content to target path', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'file-artifact-writer-'));
+        const target = (0, node_path_1.join)(dir, 'diagram.png');
+        const writer = new FileArtifactWriter_js_1.FileArtifactWriter();
+        try {
+            await writer.write({
+                target,
+                artifact: {
+                    content: Buffer.from([10, 20, 30]),
+                    mediaType: 'image/png',
+                    extension: 'png',
+                },
+            });
+            const written = await (0, promises_1.readFile)(target);
+            expect(written).toEqual(Buffer.from([10, 20, 30]));
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud fail when no target path is provided', async () => {
+        const writer = new FileArtifactWriter_js_1.FileArtifactWriter();
+        await expect(writer.write({
+            artifact: {
+                content: 'data',
+                mediaType: 'text/plain',
+            },
+        })).rejects.toThrow('FileArtifactWriter requires a target path');
+    });
+    it('shoud skip directory creation when disabled', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'file-artifact-writer-'));
+        const target = (0, node_path_1.join)(dir, 'graph.dot');
+        const writer = new FileArtifactWriter_js_1.FileArtifactWriter({ createDirectories: false });
+        try {
+            await writer.write({
+                target,
+                artifact: {
+                    content: 'digraph G {}',
+                    mediaType: 'text/vnd.graphviz',
+                    extension: 'dot',
+                },
+            });
+            const written = await (0, promises_1.readFile)(target, 'utf8');
+            expect(written).toBe('digraph G {}');
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/cjs/Output/ArtifactWriter/StdoutArtifactWriter.d.ts

@@ -0,0 +1,6 @@
+import { ArtifactWriteInput, ArtifactWriter } from '../ArtifactWriter.js';
+export declare class StdoutArtifactWriter implements ArtifactWriter {
+    private readonly stream;
+    constructor(stream?: NodeJS.WritableStream);
+    write(input: ArtifactWriteInput): Promise<void>;
+}

package/dist/cjs/Output/ArtifactWriter/StdoutArtifactWriter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StdoutArtifactWriter = void 0;
+const node_events_1 = require("node:events");
+class StdoutArtifactWriter {
+    stream;
+    constructor(stream = process.stdout) {
+        this.stream = stream;
+    }
+    async write(input) {
+        const wasWritten = this.stream.write(input.artifact.content);
+        if (!wasWritten) {
+            await (0, node_events_1.once)(this.stream, 'drain');
+        }
+    }
+}
+exports.StdoutArtifactWriter = StdoutArtifactWriter;

package/dist/cjs/Output/ArtifactWriter/StdoutArtifactWriter.test.d.ts

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