scenic-prism-playwright 0.1.0

package/dist/studio.js

@@ -0,0 +1,593 @@
+/**
+ * The browser side: a Chromium instance, and one page per image.
+ *
+ * A studio is the expensive half — launching a browser — held open so a batch
+ * of scenes can share it. Each render gets a page of its own, and with it a
+ * GPU device of its own: the library shares one device per page, and closing
+ * the page is what gives it back, whether the render finished or not.
+ *
+ * The page itself is served entirely out of this process. There is no HTTP
+ * server and no temporary directory: `page.route` intercepts an origin that
+ * does not exist, answers `/` with a canvas and `/library/*` with the files of
+ * the installed `scenic-prism`, and the page then imports the library exactly
+ * as a browser would over the network. That origin is a `.localhost` one,
+ * which a browser counts as a secure context — and WebGPU is offered to secure
+ * contexts only.
+ *
+ * The one thing WebGPU changes here is how the image comes back. A WebGL canvas can be kept readable after it is
+ * drawn; a WebGPU canvas cannot — what was drawn into it is gone once it has
+ * been shown — so reading the finished canvas finds nothing. The page instead
+ * renders with `retain`, asks the handle for the pixels with `readPixels()`,
+ * and encodes those through a 2D canvas of its own.
+ */
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { chromium } from 'playwright';
+import { toSceneSpec } from 'scenic-prism-fluent';
+import { MIME_TYPES, checkQuality, decodeDataUrl, formatForPath } from "./image.js";
+import { addMargin, resolveMargin } from "./margin.js";
+import { browserEntry, contentType, resolveLibraryRoot, resolveServedFile } from "./library.js";
+/**
+ * The origin the page is served on. Nothing is listening there and nothing ever
+ * will be: every request for it is fulfilled by the route handler below, before
+ * the browser looks for a host. `.localhost` is reserved for exactly this, so
+ * the name can never start resolving to somebody else's machine.
+ */
+const ORIGIN = 'http://scenic-prism.localhost';
+/** Where the served copy of `scenic-prism` is mounted under that origin. */
+const LIBRARY_PREFIX = '/library/';
+/** Where the loaded library is left for the traced function to find. */
+const LIBRARY_GLOBAL = '__scenicPrismLibrary';
+/**
+ * The whole page: an import of the library, and nothing to lay out.
+ *
+ * The import is a module script in the markup rather than a dynamic `import()`
+ * inside the traced function, and deliberately so. That function is sent to the
+ * browser as source, and TypeScript compiles `import(someVariable)` into a call
+ * to a helper of its own that exists in this process and not in the page — so
+ * the one thing this file must never do is write a dynamic import in the code
+ * that crosses. A `<script type="module">` cannot be rewritten by anybody.
+ */
+function pageHtml(entryUrl) {
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>scenic-prism-playwright</title>
+    <style>
+      html, body { margin: 0; padding: 0; background: #000; }
+      canvas { display: block; }
+    </style>
+    <script type="module">
+      import * as library from '${entryUrl}';
+      globalThis.${LIBRARY_GLOBAL} = library;
+    </script>
+  </head>
+  <body></body>
+</html>
+`;
+}
+/**
+ * Switches every launch takes, whichever adapter is behind it. WebGPU is still
+ * behind a switch in the Chromium builds Playwright manages; the rest matter
+ * because the render loop is `requestAnimationFrame`, and a page nobody is
+ * looking at is entitled to be slowed right down.
+ */
+const SHARED_BROWSER_ARGS = [
+    '--enable-unsafe-webgpu',
+    '--disable-background-timer-throttling',
+    '--disable-backgrounding-occluded-windows',
+    '--disable-renderer-backgrounding',
+];
+/**
+ * Software rendering, asked for explicitly: SwiftShader's WebGPU adapter and
+ * nothing else, whatever the machine has. This is what `gpu: false` launches
+ * with, and it is the only setting under which two machines agree pixel for
+ * pixel — a GPU and a software rasteriser round differently, so the same
+ * `seed` on each gives images that look identical and hash differently.
+ */
+export const SOFTWARE_BROWSER_ARGS = [
+    ...SHARED_BROWSER_ARGS,
+    '--use-webgpu-adapter=swiftshader',
+    '--enable-unsafe-swiftshader',
+];
+/**
+ * Asking for hardware, as plainly as Chromium allows: the GPU switched on for
+ * headless, and the blocklist ignored so a driver Chrome merely distrusts is
+ * still used for a render nobody is browsing with. On Linux, Chromium's WebGPU
+ * runs on Vulkan, which it does not turn on by itself.
+ */
+const HARDWARE_BROWSER_ARGS = [
+    '--enable-gpu',
+    '--ignore-gpu-blocklist',
+    ...(process.platform === 'linux' ? ['--enable-features=Vulkan'] : []),
+];
+/**
+ * Hardware and no substitute: what `gpu: true` launches with. Chromium is asked
+ * to leave the software fallback out altogether — though that is not what
+ * enforces `true`, since a browser is entitled to hand out its fallback adapter
+ * anyway. What enforces it is {@link requireHardware}, which asks a page which
+ * adapter it would actually trace with.
+ */
+export const GPU_BROWSER_ARGS = [
+    ...SHARED_BROWSER_ARGS,
+    ...HARDWARE_BROWSER_ARGS,
+    '--disable-software-rasterizer',
+];
+/**
+ * What a launch takes by default: the hardware switches, and permission to fall
+ * back to SwiftShader rather than the instruction not to. A browser with no GPU
+ * to offer hands a page SwiftShader's adapter by itself, which is why `'auto'`
+ * needs no probe of its own — the browser answers the question by starting.
+ *
+ * Chromium takes the last occurrence of a switch, so anything passed in
+ * `launch.args` still overrides what is here.
+ */
+export const DEFAULT_BROWSER_ARGS = [
+    ...SHARED_BROWSER_ARGS,
+    ...HARDWARE_BROWSER_ARGS,
+    '--enable-unsafe-swiftshader',
+];
+/**
+ * The channel a hardware launch asks for. Playwright's default headless
+ * Chromium is the *headless shell*, a build with no GPU stack in it at all, so
+ * asking for a GPU means asking for the full browser as well. A Playwright too
+ * old to know the channel, or an install without that browser, is why the
+ * launch plan below has a second attempt in it.
+ */
+const GPU_CHANNEL = 'chromium';
+/** The args for a preference, before the caller's own are appended. */
+function browserArgsFor(gpu) {
+    if (gpu === false)
+        return SOFTWARE_BROWSER_ARGS;
+    if (gpu === true)
+        return GPU_BROWSER_ARGS;
+    return DEFAULT_BROWSER_ARGS;
+}
+/**
+ * The launches to try, in order, for a preference — each one falling back to
+ * the next only if Chromium refuses to start at all.
+ *
+ * A caller who named a `channel` or an `executablePath` has said which binary
+ * to run, so that one is left alone and there is nothing to fall back to.
+ */
+export function launchPlan(gpu, launch = {}) {
+    const attempt = (args, extra = {}) => ({
+        ...extra,
+        ...launch,
+        args: [...args, ...(launch.args ?? [])],
+    });
+    const software = attempt(SOFTWARE_BROWSER_ARGS);
+    if (gpu === false)
+        return [software];
+    const args = browserArgsFor(gpu);
+    const binaryChosen = launch.channel !== undefined || launch.executablePath !== undefined;
+    const hardware = binaryChosen
+        ? [attempt(args)]
+        : // The full browser first, then whatever `chromium` is on an installation
+            // that has no such channel — which on Playwright before 1.49 is the full
+            // browser anyway, and so is worth asking.
+            [attempt(args, { channel: GPU_CHANNEL }), attempt(args)];
+    return gpu === true ? hardware : [...hardware, software];
+}
+/**
+ * Adapter names that mean nobody's silicon was involved. The name is read off
+ * the page's WebGPU adapter, which is the only honest place to read it: what
+ * Chromium was *asked* for and what it ended up doing are different questions.
+ */
+const SOFTWARE_RENDERERS = /swiftshader|llvmpipe|lavapipe|softpipe|software|basic render/i;
+/** Whether a reported adapter is a software one. */
+export function isSoftwareAdapter({ renderer, fallback }) {
+    return fallback || SOFTWARE_RENDERERS.test(renderer);
+}
+/**
+ * Whether a failed render looks like it failed for want of a working GPU,
+ * rather than for a reason a different browser would fail for too. No adapter
+ * is what a page reports when Chromium's GPU process never came up and
+ * SwiftShader was not permitted behind it.
+ */
+function looksLikeGraphicsFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /webgpu|gpu|adapter|device|graphics|swiftshader|vulkan|metal/i.test(message);
+}
+/**
+ * How long a single render is given before it is abandoned. Generous on
+ * purpose: a thousand samples of a glassy scene at 1024² is minutes of software
+ * path tracing, and a timeout that fires on a render that was going to finish
+ * is worse than one that fires late.
+ */
+export const DEFAULT_TIMEOUT = 300_000;
+/** The name the page calls back on. Bound only when there is a listener. */
+const PROGRESS_BINDING = '__scenicPrismProgress';
+/**
+ * The whole of the in-page work, and the only code here that runs in the
+ * browser. It takes the library the document loaded, traces until the
+ * accumulation finishes on its own, and reads the finished image back.
+ *
+ * Read back from the render rather than from the canvas: a WebGPU canvas does
+ * not keep what was drawn into it once that has been shown, so the render is
+ * started with `retain` and asked for its pixels, which are then encoded
+ * through a 2D canvas — the one thing in a browser that turns pixels into a
+ * PNG, a JPEG or a WebP. The render itself goes to an `OffscreenCanvas`, which
+ * the library draws into exactly as it would a canvas on a page.
+ *
+ * This function is sent across as source, so it can close over nothing: every
+ * value it needs, including the names of the two globals, arrives in `job`.
+ *
+ * Exported for `studio.test.ts` alone — `index.ts` does not re-export it, so it
+ * is no part of the package's surface. Being sent across as source is exactly
+ * why it is worth calling directly: nothing else here would catch a mistake in
+ * it before a browser did.
+ */
+export async function traceInPage(job) {
+    const globals = globalThis;
+    const library = globals[job.library];
+    if (!library)
+        throw new Error('the page did not load scenic-prism');
+    // Offscreen: nothing here is ever shown, and Playwright's headless shell —
+    // the Chromium a software render launches — loses the device a few frames
+    // into presenting WebGPU to a canvas in the document. The render sizes it.
+    const canvas = new OffscreenCanvas(1, 1);
+    const report = globals[job.binding];
+    const onProgress = job.reportProgress && typeof report === 'function'
+        ? (frames, total) => {
+            // Fire and forget: awaiting a binding round-trip on every frame would
+            // pace the render against the process driving it.
+            void report(frames, total);
+        }
+        : undefined;
+    // A device lost mid-render ends it early, and `done` resolves as though it
+    // had merely stopped: kept here so the image is not saved half-traced.
+    let lost;
+    const handle = library.render(canvas, job.spec, {
+        ...job.trace,
+        onProgress,
+        // A method rather than an arrow in a property: a TypeScript runner that
+        // keeps function names — tsx does — wraps a named arrow in a helper that
+        // exists in Node and not in the page this function is sent to.
+        onDeviceLost(info) {
+            lost = info;
+        },
+        retain: true,
+    });
+    try {
+        // `ready` first: a render that could not start settles `done` too, with
+        // nothing, and it is the failure that is worth reporting.
+        await handle.ready;
+        const frames = await handle.done;
+        if (lost) {
+            throw new Error(`the GPU device was lost after ${frames} samples (${lost.reason}): ${lost.message}`);
+        }
+        const pixels = await handle.readPixels();
+        const colorSpace = handle.colorSpace;
+        const out = document.createElement('canvas');
+        out.width = pixels.width;
+        out.height = pixels.height;
+        const context = out.getContext('2d', { colorSpace });
+        if (!context)
+            throw new Error('the page could not make a 2D canvas to encode the image with');
+        context.putImageData(new ImageData(pixels.data, pixels.width, pixels.height, {
+            colorSpace,
+        }), 0, 0);
+        // The adapter the library took, asked for again: the same browser flags
+        // give the same answer. Which card drew the image is not worth failing a
+        // render over, so a browser that will not say reports an empty name.
+        let adapter = { renderer: '', fallback: false };
+        try {
+            const found = await navigator.gpu.requestAdapter();
+            if (found) {
+                const info = found.info;
+                adapter = {
+                    renderer: [info.vendor, info.architecture, info.device, info.description]
+                        .filter(Boolean)
+                        .join(' '),
+                    fallback: info.isFallbackAdapter === true,
+                };
+            }
+        }
+        catch {
+            // As above.
+        }
+        return {
+            dataUrl: out.toDataURL(job.mimeType, job.quality),
+            width: pixels.width,
+            height: pixels.height,
+            frames,
+            adapter,
+            colorSpace,
+        };
+    }
+    finally {
+        handle.stop();
+    }
+}
+/**
+ * Which adapter a page would trace with, asked before anything is traced. Sent
+ * across as source like {@link traceInPage}, so it closes over nothing and
+ * reads no globals. `null` is a page with no WebGPU adapter at all.
+ *
+ * Exported for the tests on the same terms as {@link traceInPage}.
+ */
+export async function probeAdapterInPage() {
+    if (typeof navigator === 'undefined' || !navigator.gpu)
+        return null;
+    const adapter = await navigator.gpu.requestAdapter();
+    if (!adapter)
+        return null;
+    const info = adapter.info;
+    return {
+        renderer: [info.vendor, info.architecture, info.device, info.description]
+            .filter(Boolean)
+            .join(' '),
+        fallback: info.isFallbackAdapter === true,
+    };
+}
+/**
+ * Hold `gpu: true` to what it asked for, before a scene is traced rather than
+ * after. A browser that fell back to SwiftShader renders perfectly well and
+ * perhaps a hundred times slower, which is exactly the outcome somebody writing
+ * `true` wanted to hear about instead of wait out.
+ */
+async function requireHardware(browser, ownsBrowser, serve) {
+    const page = await browser.newPage();
+    let adapter = null;
+    try {
+        // Asked on the served origin, since WebGPU is only offered to a secure
+        // context and a blank page is not one.
+        await serve(page);
+        await page.goto(`${ORIGIN}/`);
+        adapter = await page.evaluate(probeAdapterInPage);
+    }
+    catch {
+        // A page that cannot answer has no WebGPU to answer about.
+    }
+    finally {
+        await page.close();
+    }
+    if (adapter && !isSoftwareAdapter(adapter))
+        return;
+    if (ownsBrowser) {
+        try {
+            await browser.close();
+        }
+        catch {
+            // Nothing to do about a browser that has already gone.
+        }
+    }
+    throw new Error('scenic-prism-playwright: `gpu: true` asked for hardware rendering, and this browser ' +
+        `${adapter ? `traces with ${adapter.renderer || 'a fallback adapter'}` : 'has no WebGPU adapter at all'}. ` +
+        "Pass `gpu: 'auto'` to render in software wherever there is no GPU to use.");
+}
+/** Reject if a promise has not settled in time, naming what was waited on. */
+async function withTimeout(work, ms, what) {
+    let timer;
+    try {
+        return await Promise.race([
+            work,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`scenic-prism-playwright: ${what} after ${ms}ms.`)), ms);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Launch the first attempt in a plan that Chromium will actually start, so a
+ * missing full-browser build is a slower render rather than a failed script.
+ */
+async function launchFirstThatStarts(plan, gpu) {
+    let failure;
+    for (const attempt of plan) {
+        try {
+            return await chromium.launch(attempt);
+        }
+        catch (error) {
+            failure = error;
+        }
+    }
+    const detail = failure instanceof Error ? failure.message : String(failure);
+    throw new Error(gpu === true
+        ? 'scenic-prism-playwright: could not launch Chromium for GPU rendering. Install the ' +
+            'full browser with `npx playwright install chromium`, or pass `gpu: false` to render ' +
+            `in software instead. (${detail})`
+        : `scenic-prism-playwright: could not launch Chromium. (${detail})`, { cause: failure });
+}
+/**
+ * Open a browser and keep it open. Every scene rendered through the returned
+ * studio shares it, which is most of the cost of the first image and all of the
+ * cost of the rest. Close it when the batch is done.
+ *
+ * The browser is asked for the machine's GPU unless `gpu` says otherwise, and
+ * takes SwiftShader wherever there is none to have. See {@link GpuPreference}.
+ */
+export async function openStudio(options = {}) {
+    // Resolved before anything is launched, so a missing library is an error
+    // about the library rather than a browser that starts and finds nothing.
+    const libraryRoot = resolve(options.libraryRoot ?? resolveLibraryRoot());
+    const html = pageHtml(`${LIBRARY_PREFIX}${browserEntry(libraryRoot)}`);
+    const defaultTimeout = options.timeout ?? DEFAULT_TIMEOUT;
+    const gpu = options.gpu ?? 'auto';
+    const ownsBrowser = options.browser === undefined;
+    let browser = options.browser ?? (await launchFirstThatStarts(launchPlan(gpu, options.launch), gpu));
+    /** Whether the one software retry below has already been spent. */
+    let fellBack = false;
+    /** Serve the page, and the library it imports, to one page. */
+    async function serve(page) {
+        await page.route(`${ORIGIN}/**`, async (route) => {
+            const { pathname } = new URL(route.request().url());
+            const notFound = () => route.fulfill({ status: 404, contentType: 'text/plain; charset=utf-8', body: 'Not found' });
+            if (pathname === '/') {
+                await route.fulfill({
+                    status: 200,
+                    contentType: 'text/html; charset=utf-8',
+                    body: html,
+                });
+                return;
+            }
+            if (!pathname.startsWith(LIBRARY_PREFIX)) {
+                await notFound();
+                return;
+            }
+            const file = resolveServedFile(libraryRoot, pathname.slice(LIBRARY_PREFIX.length - 1));
+            if (!file) {
+                await notFound();
+                return;
+            }
+            try {
+                await route.fulfill({
+                    status: 200,
+                    contentType: contentType(file),
+                    body: await readFile(file),
+                });
+            }
+            catch {
+                await notFound();
+            }
+        });
+    }
+    // Only `true` insists, so only `true` pays for a page to ask. `'auto'` takes
+    // whatever it is given, and `false` asked for the software renderer.
+    if (gpu === true)
+        await requireHardware(browser, ownsBrowser, serve);
+    /**
+     * Swap a hardware browser for a software one, once, when a render failed in a
+     * way that points at the graphics stack. Chromium falls back to SwiftShader
+     * by itself when the GPU process never comes up, so this is for the machine
+     * where it comes up and then cannot give a page a WebGPU adapter or device —
+     * rare, and cheaper to recover from than to explain.
+     */
+    async function fallBackToSoftware(error) {
+        if (gpu !== 'auto' || !ownsBrowser || fellBack)
+            return false;
+        if (!looksLikeGraphicsFailure(error))
+            return false;
+        fellBack = true;
+        try {
+            await browser.close();
+        }
+        catch {
+            // Already gone, most likely with the GPU process that took it down.
+        }
+        browser = await launchFirstThatStarts(launchPlan(false, options.launch), false);
+        return true;
+    }
+    /** One render, on the browser this studio currently holds. */
+    async function traceOnce(spec, format, 
+    // `margin` is pulled out here with `format` and the rest: what is left is
+    // handed to the page as its trace options, and a margin is not one — it is
+    // added to the encoded image in this process, after the render.
+    { format: _format, margin: _margin, quality, timeout, onProgress, ...trace }) {
+        const page = await browser.newPage();
+        // Anything the page throws on its own — the library failing to parse, a
+        // module 404 — never reaches `evaluate`, so it is kept here to be added to
+        // whatever the trace ends up complaining about.
+        const pageErrors = [];
+        page.on('pageerror', (error) => pageErrors.push(error.message));
+        try {
+            if (onProgress)
+                await page.exposeFunction(PROGRESS_BINDING, onProgress);
+            await serve(page);
+            await page.goto(`${ORIGIN}/`);
+            const job = {
+                // A `Draft` carries its chaining methods on a prototype and may hold a
+                // fluent camera; `toSceneSpec` is what turns either dialect into the
+                // plain data that can cross into the browser.
+                spec: toSceneSpec(spec),
+                trace,
+                mimeType: MIME_TYPES[format],
+                quality,
+                reportProgress: onProgress !== undefined,
+                library: LIBRARY_GLOBAL,
+                binding: PROGRESS_BINDING,
+            };
+            const result = await withTimeout(page.evaluate(traceInPage, job), timeout ?? defaultTimeout, 'the render did not finish').catch((cause) => {
+                const detail = pageErrors.length ? ` (the page reported: ${pageErrors.join('; ')})` : '';
+                throw new Error(`${cause instanceof Error ? cause.message : String(cause)}${detail}`, {
+                    cause,
+                });
+            });
+            const { mimeType, bytes } = decodeDataUrl(result.dataUrl);
+            if (mimeType !== MIME_TYPES[format]) {
+                // A canvas asked for an encoding it does not have quietly hands back a
+                // PNG. Saying so beats writing PNG bytes into the file the caller named.
+                throw new Error(`scenic-prism-playwright: this browser cannot encode ${format} — it returned ${mimeType}.`);
+            }
+            return {
+                format,
+                width: result.width,
+                height: result.height,
+                frames: result.frames,
+                bytes: bytes.length,
+                renderer: result.adapter.renderer,
+                accelerated: result.adapter.renderer !== '' && !isSoftwareAdapter(result.adapter),
+                colorSpace: result.colorSpace,
+                data: bytes,
+            };
+        }
+        finally {
+            // Closing the page is what frees its GPU device, whether the render
+            // finished, threw, or ran out of time.
+            await page.close();
+        }
+    }
+    /**
+     * Mount a finished render in its margin. The trace is over by the time this
+     * runs and knows nothing about it, so what comes back is the same image in a
+     * larger file — re-encoded in the format it arrived in, and re-measured.
+     */
+    async function mount(image, format, margin, quality) {
+        const { data, width, height } = await addMargin(image.data, format, margin, quality);
+        return { ...image, data, width, height, bytes: data.length };
+    }
+    /**
+     * A render, and — under `gpu: 'auto'` — a second attempt in software if the
+     * first one failed for want of working graphics.
+     */
+    async function trace(spec, format, renderOptions) {
+        try {
+            return await traceOnce(spec, format, renderOptions);
+        }
+        catch (error) {
+            if (await fallBackToSoftware(error))
+                return traceOnce(spec, format, renderOptions);
+            if (gpu === true && looksLikeGraphicsFailure(error)) {
+                throw new Error(`${error instanceof Error ? error.message : String(error)} — \`gpu: true\` asked ` +
+                    "for hardware rendering and this machine did not provide it. `gpu: 'auto'` " +
+                    'renders in software when there is no GPU to use.', { cause: error });
+            }
+            throw error;
+        }
+    }
+    /** One image, start to finish: what the page traced, mounted if asked. */
+    async function draw(spec, format, renderOptions) {
+        // Both checked before the browser is asked for anything, so a quality or a
+        // margin this package cannot use is an error in the first millisecond
+        // rather than after the minutes of tracing it would otherwise follow.
+        checkQuality(format, renderOptions.quality);
+        const margin = resolveMargin(renderOptions.margin);
+        const image = await trace(spec, format, renderOptions);
+        return margin ? mount(image, format, margin, renderOptions.quality) : image;
+    }
+    return {
+        async renderToBuffer(spec, renderOptions = {}) {
+            return draw(spec, renderOptions.format ?? 'png', renderOptions);
+        },
+        async renderToFile(spec, output, renderOptions = {}) {
+            const path = resolve(output);
+            // The extension is read before the browser does any work, so a name this
+            // package cannot save is an error in the first millisecond, not the last.
+            const format = renderOptions.format ?? formatForPath(output);
+            const image = await draw(spec, format, renderOptions);
+            await mkdir(dirname(path), { recursive: true });
+            await writeFile(path, image.data);
+            const { data: _data, ...rest } = image;
+            return { ...rest, path };
+        },
+        async close() {
+            if (ownsBrowser)
+                await browser.close();
+        },
+    };
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "scenic-prism-playwright",
+  "version": "0.1.0",
+  "description": "Render a scenic-prism scene to an image file from Node, by path-tracing it in a headless browser driven by Playwright.",
+  "license": "PolyForm-Noncommercial-1.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "sharp": "^0.35.4"
+  },
+  "peerDependencies": {
+    "playwright": ">=1.40",
+    "scenic-prism-fluent": ">=0.1.0"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "playwright",
+    "headless",
+    "screenshot",
+    "csg",
+    "path-tracing",
+    "webgpu",
+    "sdf",
+    "generative-art"
+  ]
+}