@tstdl/base 0.93.123 → 0.93.126

package/orm/tests/repository-cti.test.js

@@ -9,9 +9,9 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
+import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { sql } from 'drizzle-orm';
-import { beforeAll, describe, expect, test } from 'vitest';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
 import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
 import { Database, injectRepository } from '../server/index.js';
@@ -137,8 +137,10 @@ describe('ORM Repository CTI (Integration)', () => {
       )
     `);
     });
-    test('should insert into both parent and child tables', async () => {
+    beforeEach(async () => {
         await truncateTables(database, schema, ['users']);
+    });
+    test('should insert into both parent and child tables', async () => {
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(Admin);
             const newAdmin = new Admin();
@@ -154,17 +156,16 @@ describe('ORM Repository CTI (Integration)', () => {
             // Verify DB state
             const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
             expect(userRow).toBeDefined();
-            expect(userRow.type).toBe('admin');
-            expect(userRow.name).toBe('Alice');
-            expect(userRow.revision).toBe(1);
+            expect(userRow['type']).toBe('admin');
+            expect(userRow['name']).toBe('Alice');
+            expect(userRow['revision']).toBe(1);
             const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
             expect(adminRow).toBeDefined();
-            expect(adminRow.type).toBe('admin');
-            expect(adminRow.role).toBe('SuperAdmin');
+            expect(adminRow['type']).toBe('admin');
+            expect(adminRow['role']).toBe('SuperAdmin');
         });
     });
     test('should insert many into both parent and child tables', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(Admin);
             const admins = [
@@ -179,14 +180,13 @@ describe('ORM Repository CTI (Integration)', () => {
             expect(insertedAdmins[1].type).toBe('admin');
             for (const inserted of insertedAdmins) {
                 const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-                expect(userRow.name).toBe(inserted.name);
+                expect(userRow['name']).toBe(inserted.name);
                 const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
-                expect(adminRow.role).toBe(inserted.role);
+                expect(adminRow['role']).toBe(inserted.role);
             }
         });
     });
     test('should update both parent and child tables', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(Admin);
             const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
@@ -198,14 +198,13 @@ describe('ORM Repository CTI (Integration)', () => {
             expect(updated.metadata.revision).toBe(2);
             // Verify DB state
             const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-            expect(userRow.name).toBe('Alice Updated');
-            expect(userRow.revision).toBe(2);
+            expect(userRow['name']).toBe('Alice Updated');
+            expect(userRow['revision']).toBe(2);
             const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
-            expect(adminRow.role).toBe('MegaAdmin');
+            expect(adminRow['role']).toBe('MegaAdmin');
         });
     });
     test('should soft delete from parent table', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(Admin);
             const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
@@ -213,14 +212,13 @@ describe('ORM Repository CTI (Integration)', () => {
             await repository.delete(inserted.id);
             // Verify DB state
             const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-            expect(userRow.delete_timestamp).not.toBeNull();
+            expect(userRow['delete_timestamp']).not.toBeNull();
             // Child table should still have the row (soft delete only affects parent)
             const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
             expect(adminRow).toBeDefined();
         });
     });
     test('should hard delete from both tables via cascade', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(Admin);
             const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
@@ -234,7 +232,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should load entities polymorphically from parent repository', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const guestRepository = injectRepository(Guest);
@@ -265,7 +262,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should load polymorphic subset from parent repository', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const guestRepository = injectRepository(Guest);
@@ -284,7 +280,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should count and check existence for child entities', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const guestRepository = injectRepository(Guest);
@@ -300,7 +295,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should query child entities by parent fields', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             await adminRepository.insert(Object.assign(new Admin(), { name: 'TargetAdmin', role: 'Super' }));
@@ -312,7 +306,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should perform partial updates on parent or child fields', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const inserted = await adminRepository.insert(Object.assign(new Admin(), { name: 'Alice', role: 'Super' }));
@@ -351,7 +344,6 @@ describe('ORM Repository CTI (Integration)', () => {
         await expect(query).rejects.toThrow();
     });
     test('should support nested inheritance', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const managerRepository = injectRepository(Manager);
             const manager = new Manager();
@@ -365,15 +357,14 @@ describe('ORM Repository CTI (Integration)', () => {
             expect(inserted.type).toBe('manager');
             // Verify DB state - all 3 tables should have rows
             const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-            expect(userRow.name).toBe('Big Boss');
+            expect(userRow['name']).toBe('Big Boss');
             const { rows: [staffRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('staff')} WHERE id = ${inserted.id}`);
-            expect(staffRow.employee_id).toBe('EMP001');
+            expect(staffRow['employee_id']).toBe('EMP001');
             const { rows: [managerRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('managers')} WHERE id = ${inserted.id}`);
-            expect(managerRow.department).toBe('Executive');
+            expect(managerRow['department']).toBe('Executive');
         });
     });
     test('should rollback parent insert if child insert fails', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             // Attempt to insert an admin with a missing role (should fail because of NOT NULL)
@@ -387,7 +378,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should count and check existence polymorphically', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const guestRepository = injectRepository(Guest);
@@ -400,7 +390,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should load many by IDs polymorphically', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const guestRepository = injectRepository(Guest);
@@ -414,7 +403,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should update many child entities', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const a1 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'Old' }));
@@ -426,7 +414,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should update nested inheritance fields', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const managerRepository = injectRepository(Manager);
             const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });
@@ -439,7 +426,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should delete from nested inheritance tables', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const managerRepository = injectRepository(Manager);
             const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });

package/orm/tests/repository-extra-coverage.test.js

@@ -10,7 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { NotFoundError } from '../../errors/not-found.error.js';
 import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
+import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
 import { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';

package/orm/tests/repository-search.test.js

@@ -8,10 +8,10 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { sql } from 'drizzle-orm';
-import { beforeAll, describe, expect, test } from 'vitest';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
 import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest } from '../../unit-test/index.js';
+import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { Table } from '../decorators.js';
 import { Entity } from '../entity.js';
 import { Database } from '../server/index.js';
@@ -51,6 +51,9 @@ describe('ORM Repository Search', () => {
       )
     `);
     });
+    beforeEach(async () => {
+        await truncateTables(database, schema, ['search_entities']);
+    });
     test('should support search with score transformer', async () => {
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(SearchEntity);

package/orm/tests/schema-converter.test.js

@@ -42,6 +42,7 @@ describe('ORM Schema Generation - Detailed Configurations', () => {
         expect(config.indexes.length).toBeGreaterThan(0);
         const idx = config.indexes[0];
         expect(idx).toBeDefined();
+        expect(idx.config.name).toContain('partial_idx');
         expect(idx.config.where).toBeDefined();
     });
     test('should handle index with nulls ordering', () => {

package/orm/tests/transaction-safety.test.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { Injector, Singleton, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest } from '../../unit-test/index.js';
+import { dropTables, setupIntegrationTest } from '../../testing/index.js';
 import { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';
 import { Entity, Table } from '../index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.123",
+  "version": "0.93.126",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -76,7 +76,6 @@
     "./jsx": "./jsx/index.js",
     "./key-value-store": "./key-value-store/index.js",
     "./key-value-store/postgres": "./key-value-store/postgres/index.js",
-    "./latex": "./latex/index.js",
     "./lock": "./lock/index.js",
     "./lock/postgres": "./lock/postgres/index.js",
     "./lock/web": "./lock/web/index.js",
@@ -93,8 +92,8 @@
     "./object-storage/s3": "./object-storage/s3/index.js",
     "./openid-connect": "./openid-connect/index.js",
     "./orm": "./orm/index.js",
-    "./orm/schemas": "./orm/schemas/index.js",
     "./orm/data-types": "./orm/data-types/index.js",
+    "./orm/schemas": "./orm/schemas/index.js",
     "./orm/server": "./orm/server/index.js",
     "./password": "./password/index.js",
     "./pdf": "./pdf/index.js",
@@ -105,6 +104,7 @@
     "./rate-limit": "./rate-limit/index.js",
     "./rate-limit/postgres": "./rate-limit/postgres/index.js",
     "./reflection": "./reflection/index.js",
+    "./renderer": "./renderer/index.js",
     "./rpc": "./rpc/index.js",
     "./rpc/endpoints": "./rpc/endpoints/index.js",
     "./rxjs-utils": "./rxjs-utils/index.js",
@@ -125,11 +125,10 @@
     "./templates/renderers": "./templates/renderers/index.js",
     "./templates/resolvers": "./templates/resolvers/index.js",
     "./templates/types": "./templates/types/index.js",
+    "./testing": "./testing/index.js",
     "./text": "./text/index.js",
     "./threading": "./threading/index.js",
     "./types": "./types/index.js",
-    "./typst": "./typst/index.js",
-    "./unit-test": "./unit-test/index.js",
     "./utils": "./utils/index.js",
     "./utils/array": "./utils/array/index.js",
     "./utils/async-hook": "./utils/async-hook/index.js",
@@ -153,7 +152,6 @@
   "peerDependencies": {
     "@genkit-ai/google-genai": "^1.28",
     "@google-cloud/storage": "^7.19",
-    "@google/genai": "^1.40",
     "@toon-format/toon": "^2.1.0",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
@@ -164,8 +162,8 @@
     "file-type": "^21.3",
     "genkit": "^1.28",
     "handlebars": "^4.7",
-    "@aws-sdk/client-s3": "^3.986",
-    "@aws-sdk/s3-request-presigner": "^3.986",
+    "@aws-sdk/client-s3": "^3.990",
+    "@aws-sdk/s3-request-presigner": "^3.990",
     "mjml": "^4.18",
     "nodemailer": "^8.0",
     "pg": "^8.18",
@@ -173,7 +171,7 @@
     "preact": "^10.28",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
-    "undici": "^7.21",
+    "undici": "^7.22",
     "urlpattern-polyfill": "^10.1",
     "zod": "^3.25"
   },

package/rate-limit/tests/postgres-rate-limiter.test.js

@@ -1,26 +1,23 @@
-import { afterAll, describe, expect, it } from 'vitest';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { RateLimiterProvider } from '../../rate-limit/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('PostgresRateLimiter Integration Tests', () => {
     let injector;
     let rateLimiter;
     const limiterName = `test-limiter-${Date.now()}`;
-    async function getLimiter() {
-        if (injector == null) {
-            ({ injector } = await setupIntegrationTest({ modules: { rateLimiter: true } }));
-        }
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { rateLimiter: true } }));
         const rateLimiterProvider = injector.resolve(RateLimiterProvider);
-        return rateLimiterProvider.get(limiterName, {
+        rateLimiter = rateLimiterProvider.get(limiterName, {
             burstCapacity: 10,
             refillInterval: 1000, // 10 tokens per second -> 1 token per 100ms
         });
-    }
+    });
     afterAll(async () => {
         await injector?.dispose();
     }, 15000);
     it('should acquire tokens successfully', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-1';
         const result = await rateLimiter.tryAcquire(resource, 5);
         expect(result).toBe(true);
@@ -30,7 +27,6 @@ describe('PostgresRateLimiter Integration Tests', () => {
         expect(result3).toBe(false);
     });
     it('should refill tokens over time', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-2';
         await rateLimiter.tryAcquire(resource, 10);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
@@ -40,7 +36,6 @@ describe('PostgresRateLimiter Integration Tests', () => {
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
     });
     it('should refund tokens', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-3';
         await rateLimiter.tryAcquire(resource, 10);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
@@ -49,14 +44,12 @@ describe('PostgresRateLimiter Integration Tests', () => {
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
     });
     it('should handle fractional tokens', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-4';
         await rateLimiter.tryAcquire(resource, 9.5);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
         expect(await rateLimiter.tryAcquire(resource, 0.5)).toBe(true);
     });
     it('should handle concurrent acquisitions', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-concurrent';
         // Initialize
         await rateLimiter.tryAcquire(resource, 0);
@@ -65,19 +58,16 @@ describe('PostgresRateLimiter Integration Tests', () => {
         expect(successCount).toBe(10);
     }, 15000);
     it('should always allow zero or negative cost', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-zero';
         expect(await rateLimiter.tryAcquire(resource, 0)).toBe(true);
         expect(await rateLimiter.tryAcquire(resource, -1)).toBe(true);
     });
     it('should reject cost greater than burst capacity', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-large';
         // Burst capacity is 10
         expect(await rateLimiter.tryAcquire(resource, 11)).toBe(false);
     });
     it('should cap tokens at burst capacity on refill', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-refill-cap';
         // Drain
         await rateLimiter.tryAcquire(resource, 10);

package/renderer/d2.d.ts

@@ -0,0 +1,77 @@
+export type D2RenderOptions = {
+    /**
+     * The layout engine to use.
+     * @default 'dagre'
+     */
+    layout?: string;
+    /**
+     * The theme ID to use.
+     * @default 0
+     */
+    theme?: number;
+    /**
+     * The dark theme ID to use.
+     */
+    darkTheme?: number;
+    /**
+     * Pixels padded around the rendered diagram.
+     * @default 100
+     */
+    pad?: number;
+    /**
+     * Render the diagram to look like it was sketched by hand.
+     * @default false
+     */
+    sketch?: boolean;
+    /**
+     * Center the SVG in the containing viewbox.
+     * @default false
+     */
+    center?: boolean;
+    /**
+     * if given, multiple boards are packaged as 1 SVG which transitions through each board at the interval (in milliseconds).
+     * Can only be used with SVG exports.
+     * @default 0
+     */
+    animateInterval?: number;
+    /**
+     * Omit XML tag (<?xml ...?>) from output SVG files.
+     * @default false
+     */
+    noXmlTag?: boolean;
+    /**
+     * Add a salt value to ensure the output uses unique IDs.
+     */
+    salt?: string;
+    /**
+     * Omit D2 version from generated image.
+     * @default false
+     */
+    omitVersion?: boolean;
+    /**
+     * Target board to render.
+     * @default '*'
+     */
+    target?: string;
+    /**
+     * Scale the output. E.g., 0.5 to halve the default size.
+     * @default -1
+     */
+    scale?: number;
+    /**
+     * The output format for the rendered diagram.
+     * @default 'svg'
+     */
+    format?: 'svg' | 'png' | 'ascii' | 'txt' | 'pdf' | 'pptx' | 'gif';
+};
+/**
+ * Renders D2 source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted D2 source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires d2 to be installed on the system.
+ * @param source The D2 source code to render
+ * @param options Rendering options
+ */
+export declare function renderD2(source: string, options?: D2RenderOptions): Promise<Uint8Array<ArrayBuffer>>;

package/renderer/d2.js

@@ -0,0 +1,68 @@
+import { spawnCommand } from '../process/spawn.js';
+import { decodeText } from '../utils/encoding.js';
+import { isDefined } from '../utils/type-guards.js';
+/**
+ * Renders D2 source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted D2 source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires d2 to be installed on the system.
+ * @param source The D2 source code to render
+ * @param options Rendering options
+ */
+export async function renderD2(source, options) {
+    const format = options?.format ?? 'svg';
+    const args = ['-', '-', '--stdout-format', format];
+    if (isDefined(options?.layout)) {
+        args.push('--layout', options.layout);
+    }
+    if (isDefined(options?.theme)) {
+        args.push('--theme', options.theme.toString());
+    }
+    if (isDefined(options?.darkTheme)) {
+        args.push('--dark-theme', options.darkTheme.toString());
+    }
+    if (isDefined(options?.pad)) {
+        args.push('--pad', options.pad.toString());
+    }
+    if (options?.sketch == true) {
+        args.push('--sketch');
+    }
+    if (options?.center == true) {
+        args.push('--center');
+    }
+    if (isDefined(options?.animateInterval)) {
+        args.push('--animate-interval', options.animateInterval.toString());
+    }
+    if (options?.noXmlTag == true) {
+        args.push('--no-xml-tag');
+    }
+    if (isDefined(options?.salt)) {
+        args.push('--salt', options.salt);
+    }
+    if (options?.omitVersion == true) {
+        args.push('--omit-version');
+    }
+    if (isDefined(options?.target)) {
+        args.push('--target', options.target);
+    }
+    if (isDefined(options?.scale)) {
+        args.push('--scale', options.scale.toString());
+    }
+    const process = await spawnCommand('d2', args);
+    const [{ code, output, error }] = await Promise.all([
+        process.waitRead('binary', { throwOnNonZeroExitCode: false }),
+        process.write(source),
+    ]);
+    const errorString = decodeText(error);
+    if (code !== 0) {
+        throw new Error(`
+D2 rendering failed with exit code ${code}.
+
+Error Output:
+${errorString}
+`.trim());
+    }
+    return output;
+}

package/renderer/graphviz.d.ts

@@ -0,0 +1,47 @@
+export type GraphvizRenderOptions = {
+    /**
+     * The layout engine to use.
+     * @default 'dot'
+     */
+    engine?: 'dot' | 'neato' | 'fdp' | 'sfdp' | 'twopi' | 'circo';
+    /**
+     * The output format for the rendered diagram.
+     * @default 'svg'
+     */
+    format?: 'svg' | 'png' | 'pdf' | 'jpg' | 'gif' | 'bmp' | 'eps' | 'ps' | 'tiff' | 'webp' | 'canon' | 'dot' | 'xdot' | 'plain' | 'plain-ext';
+    /**
+     * Set graph attributes (equivalent to -Gname=val)
+     */
+    graphAttributes?: Record<string, string>;
+    /**
+     * Set node attributes (equivalent to -Nname=val)
+     */
+    nodeAttributes?: Record<string, string>;
+    /**
+     * Set edge attributes (equivalent to -Ename=val)
+     */
+    edgeAttributes?: Record<string, string>;
+    /**
+     * Scale input by 'scale' (equivalent to -s[scale])
+     */
+    scale?: number;
+    /**
+     * Invert y coordinate in output (equivalent to -y)
+     */
+    invertY?: boolean;
+    /**
+     * Set level of message suppression (equivalent to -q[quiet])
+     */
+    quiet?: boolean | number;
+};
+/**
+ * Renders Graphviz (DOT) source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted Graphviz source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires Graphviz to be installed on the system.
+ * @param source The Graphviz source code to render
+ * @param options Rendering options
+ */
+export declare function renderGraphviz(source: string, options?: GraphvizRenderOptions): Promise<Uint8Array<ArrayBuffer>>;

package/renderer/graphviz.js

@@ -0,0 +1,58 @@
+import { spawnCommand } from '../process/spawn.js';
+import { decodeText } from '../utils/encoding.js';
+import { isDefined } from '../utils/type-guards.js';
+/**
+ * Renders Graphviz (DOT) source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted Graphviz source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires Graphviz to be installed on the system.
+ * @param source The Graphviz source code to render
+ * @param options Rendering options
+ */
+export async function renderGraphviz(source, options) {
+    const engine = options?.engine ?? 'dot';
+    const format = options?.format ?? 'svg';
+    const args = [`-T${format}`];
+    if (isDefined(options?.graphAttributes)) {
+        for (const [name, val] of Object.entries(options.graphAttributes)) {
+            args.push(`-G${name}=${val}`);
+        }
+    }
+    if (isDefined(options?.nodeAttributes)) {
+        for (const [name, val] of Object.entries(options.nodeAttributes)) {
+            args.push(`-N${name}=${val}`);
+        }
+    }
+    if (isDefined(options?.edgeAttributes)) {
+        for (const [name, val] of Object.entries(options.edgeAttributes)) {
+            args.push(`-E${name}=${val}`);
+        }
+    }
+    if (isDefined(options?.scale)) {
+        args.push(`-s${options.scale}`);
+    }
+    if (options?.invertY == true) {
+        args.push('-y');
+    }
+    if (isDefined(options?.quiet)) {
+        const level = (options.quiet == true) ? '' : options.quiet.toString();
+        args.push(`-q${level}`);
+    }
+    const process = await spawnCommand(engine, args);
+    const [{ code, output, error }] = await Promise.all([
+        process.waitRead('binary', { throwOnNonZeroExitCode: false }),
+        process.write(source),
+    ]);
+    const errorString = decodeText(error);
+    if (code !== 0) {
+        throw new Error(`
+Graphviz rendering failed with exit code ${code}.
+
+Error Output:
+${errorString}
+`.trim());
+    }
+    return output;
+}