scenic-prism-playwright 0.1.0

package/LICENSE

@@ -0,0 +1,133 @@
+# PolyForm Noncommercial License 1.0.0
+
+<https://polyformproject.org/licenses/noncommercial/1.0.0>
+
+Required Notice: Copyright James Porter (https://scenic-prism.pages.dev/license)
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose. However, you may
+only distribute the software according to [Distribution
+License](#distribution-license) and make changes or new works
+based on the software according to [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software. Your license
+to distribute covers distributing the software with
+changes and new works permitted by [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with `Required Notice:` that the licensor provided
+with the software. For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for
+the benefit of public knowledge, personal study, private
+entertainment, hobby projects, amateur pursuits, or religious
+observance, without any anticipated commercial application,
+is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution,
+public research organization, public safety or health
+organization, environmental protection organization,
+or government institution is use for a permitted purpose
+regardless of the source of funding or obligations resulting
+from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else. These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice. Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+**_As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim._**
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+organizations that have control over, are under the control of,
+or are under common control with that organization. **Control**
+means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote,
+contract, or otherwise. Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.

package/README.md

@@ -0,0 +1,240 @@
+# scenic-prism-playwright
+
+[`scenic-prism`](https://www.npmjs.com/package/scenic-prism) scenes, path-traced
+to image files from Node.
+
+```ts
+import { backgrounds, materials, plane, sphere } from 'scenic-prism-fluent';
+import { renderToFile } from 'scenic-prism-playwright';
+
+const SCENE = {
+  scene: sphere(1).paint(materials.chrome).union(plane([0, 1, 0], -1)),
+  background: backgrounds.dusk,
+};
+
+await renderToFile(SCENE, 'renders/chrome.png', { size: 1200, maxFrames: 900, seed: 7 });
+```
+
+One call opens a headless Chromium, traces the scene until the accumulation
+reaches its sample budget, writes the file and shuts the browser down again —
+from a script, in CI, on a machine with no screen.
+
+The headless page uses your installed copy of `scenic-prism` and calls its
+`render()` function, just as a browser canvas does.
+
+## Install
+
+```sh
+npm install scenic-prism-playwright scenic-prism-fluent playwright
+# or: pnpm add scenic-prism-playwright scenic-prism-fluent playwright
+npx playwright install chromium
+```
+
+The two large dependencies are **peers**, and both are bounded from below only:
+
+| Peer | Range | Why |
+| --- | --- | --- |
+| `scenic-prism-fluent` | `>=` this package's version | It carries `scenic-prism`, and the copy it resolves is the one that gets served to the page. |
+| `playwright` | `>=1.40` | Its browsers are your project's to install and version. |
+
+It installs one thing of its own — `sharp` — and only uses it for `margin`,
+which is drawn onto the finished image after the browser has closed.
+
+Run TypeScript scripts with `tsx render.ts` or
+`node --experimental-strip-types render.ts`. JavaScript scripts run directly
+with Node. The package ships ESM with TypeScript declarations.
+
+## `renderToFile(spec, output, options?)`
+
+Traces one scene and writes it. The encoding comes from the file's extension —
+`.png`, `.jpg`, `.jpeg` or `.webp` — unless `format` says otherwise, and any
+directories in the path are created. Returns `{ path, format, width, height,
+frames, bytes, renderer, accelerated, colorSpace }` — `renderer` and
+`accelerated` being what WebGPU said drew it, and whether that was hardware.
+
+`renderToBuffer(spec, options?)` is the same render handed back as
+`{ data: Buffer, … }`, for something that is going to upload it rather than
+keep it. `format` defaults to `png` there, there being no filename to read.
+
+| Option | | |
+| --- | --- | --- |
+| `size` | `number` | Square backing resolution in pixels (default 1024). |
+| `width` `height` | `number` | The same, when the image is not square. |
+| `maxFrames` | `number` | Samples per pixel to accumulate (default 1200). |
+| `bounces` | `number` | Light-bounce budget (default 6); glass and metal reward 8–12. |
+| `tone` | `'aces' \| 'reinhard' \| 'linear'` | The curve that brings the traced light into display range (default `'aces'`). |
+| `exposure` | `number` | Exposure in stops, before that curve: `-1` is half as bright, `+2` four times (default 0). |
+| `alpha` | `boolean` | Save a cut-out rather than a background: rays that leave the scene write no coverage (default false). Wants a format with an alpha channel — `png` or `webp`. |
+| `seed` | `number` | Fix the sample sequence. Without one, two runs differ in their noise. |
+| `format` | `'png' \| 'jpeg' \| 'webp'` | Overrides the extension. |
+| `quality` | `number` | Encoder quality in (0, 1], for `jpeg` and `webp`. |
+| `margin` | `{ size, colour? }` | A border of flat colour around the image: `size` whole pixels on each side, in the `[r, g, b]` triple used everywhere else (0..1, white by default). |
+| `timeout` | `number` | Milliseconds before the render is abandoned (default 300000). |
+| `onProgress` | `(frames, total) => void` | After every accumulated frame, in your process. |
+| `gpu` | `boolean \| 'auto'` | Render on the machine's GPU (default `'auto'`: hardware where there is any, software where there is not). |
+| `launch` | `LaunchOptions` | Passed to `chromium.launch()`, on top of this package's own arguments. |
+| `browser` | `Browser` | A Playwright browser to draw in, instead of launching one. |
+| `libraryRoot` | `string` | The `scenic-prism` package root to serve. Resolved for you by default. |
+
+### `margin`
+
+A margin is added **after** the render, not before it. The page is served and
+the canvas is sized exactly as they would be without one, so a scene traced at
+`size: 1200` holds the same 1200² of image whether it is mounted or not — it
+simply lands in a larger file. Widening the canvas instead would have widened
+the field of view with it, which is a different picture rather than a mounted
+one.
+
+```ts
+await renderToFile(SCENE, 'renders/plate.png', {
+  size: 1200,
+  margin: { size: 64, colour: [0.96, 0.95, 0.92] }, // 1328² of file, 1200² of scene
+});
+```
+
+`size` is a whole number of pixels greater than zero and `colour` is the same
+`[r, g, b]` triple as everywhere else, defaulting to white — but unlike a colour
+in a scene it is never traced and never tonemapped, so it is the colour of the
+file: `[0, 0, 0]` is black and `[0.5, 0.5, 0.5]` is the middle of the range the
+file can hold. Components outside 0..1 have nowhere to go and are refused. The
+border is opaque whatever the image is, so an `alpha` render comes back as a
+cut-out standing on that colour. `width` and `height` on the result count it.
+
+A margin means the image is encoded twice — once by the canvas, once when the
+border is drawn — so on a `jpeg` or a `webp` it costs one further generation of
+the encoder, at whatever `quality` the render was saved at.
+
+Everything the scene itself can do is unchanged — this package adds no
+vocabulary and re-exports none. Build scenes with `scenic-prism-fluent` (or with
+`scenic-prism` directly) and hand them over; either dialect is accepted, and a
+fluent `camera(...)` is normalised on the way in.
+
+## `openStudio(options?)`
+
+Launching the browser is most of the cost of the first image and all of the cost
+of the rest, so a script writing more than one should open a studio and keep it:
+
+```ts
+import { openStudio } from 'scenic-prism-playwright';
+
+const studio = await openStudio();
+try {
+  for (const [index, scene] of SCENES.entries()) {
+    await studio.renderToFile(scene, `renders/plate-${index}.png`, { size: 900, seed: 3 });
+  }
+} finally {
+  await studio.close();
+}
+```
+
+The studio takes the browser options (`gpu`, `launch`, `browser`, `libraryRoot`,
+`timeout`) and exposes the same `renderToFile` / `renderToBuffer`, each on a page
+of its own — so each render gets its own GPU device and gives it back. Given
+an existing `browser`, the studio never launches or closes anything, which is
+what makes it usable from inside a Playwright test.
+
+## What it actually does
+
+It launches Chromium with WebGPU switched on, and hands a page your copy of
+`scenic-prism` as ES modules, resolved off disk from the fluent package you
+installed. The page imports it and calls `render()`. There is no HTTP server
+and no temporary directory — the requests, for a `.localhost` origin that
+counts as a secure context and so gets WebGPU, are intercepted by Playwright
+and answered from memory.
+
+Reading the image back takes one extra step. A WebGPU canvas does not keep what was drawn into it once that has been shown, so
+the page renders with the core's `retain` option and reads the finished image
+with `handle.readPixels()` — the same tonemap, drawn into a texture and copied
+back — then encodes those pixels through a 2D canvas.
+
+## GPU or software
+
+Path tracing is the same work wherever it runs, and a graphics card does it
+between ten and a hundred times faster than a CPU pretending to be one. So the
+browser is asked for **the GPU by default**, and is given permission to fall
+back to SwiftShader's software WebGPU adapter — which is what happens, by itself,
+inside the build container that has no GPU at all. Nothing needs configuring
+either way:
+
+```ts
+const image = await renderToFile(SCENE, 'renders/plate.png', { size: 1600 });
+image.renderer; // 'apple metal-3' — the adapter's vendor and architecture
+image.accelerated; // true
+```
+
+Asking for the GPU means asking Playwright for the **full Chromium build** as
+well (`channel: 'chromium'`), because its default headless binary is the
+*headless shell*, which has no GPU stack in it. On Linux, Vulkan is switched on
+too, since that is what Chromium's WebGPU runs on there. `npx playwright install
+chromium` fetches both, and a launch that cannot find the full one quietly tries
+the ordinary binary and then software, so this never becomes a script that fails
+instead of rendering.
+
+`gpu` is the opt-out, and the opt-in-and-insist:
+
+| `gpu` | |
+| --- | --- |
+| `'auto'` *(default)* | Hardware where the machine has some, SwiftShader where it does not. |
+| `false` | SwiftShader everywhere. **The reproducible one**: a GPU and a software adapter round differently, so only this setting makes the same scene and `seed` give the same bytes on every machine. |
+| `true` | Hardware or nothing — the render fails rather than quietly taking twenty minutes over what should have taken one. |
+
+```ts
+// A plate that is going to be committed, and diffed, and re-rendered by
+// somebody else's machine.
+await renderToFile(SCENE, 'renders/plate.png', { gpu: false, seed: 7 });
+```
+
+Software path tracing is minutes, not seconds, for a large image at a high
+sample count, so a script that opts out should raise `timeout` and report
+progress:
+
+```ts
+await renderToFile(SCENE, 'renders/poster.png', {
+  gpu: false,
+  size: 1600,
+  maxFrames: 2000,
+  timeout: 30 * 60 * 1000,
+  onProgress: (frames, total) => process.stdout.write(`\r${frames}/${total}`),
+});
+```
+
+Anything finer than that is a Chromium switch, and `launch` goes straight to
+Playwright. The last occurrence of a switch wins, so the defaults can be
+overridden one at a time:
+
+```ts
+await renderToFile(SCENE, 'renders/plate.png', {
+  launch: { channel: 'chrome', args: ['--use-webgpu-adapter=swiftshader'] },
+});
+```
+
+`DEFAULT_BROWSER_ARGS`, `GPU_BROWSER_ARGS`, `SOFTWARE_BROWSER_ARGS`,
+`DEFAULT_TIMEOUT` and `launchPlan(gpu, launch?)` are exported, for a script that
+wants to say what it is changing — or to print what it would have launched.
+
+## Documentation
+
+- [`/scenic-prism-playwright`](https://scenic-prism.pages.dev/scenic-prism-playwright)
+  — this package, with four worked examples
+- [`scenic-prism-fluent`](https://www.npmjs.com/package/scenic-prism-fluent) —
+  the chainable API these examples are written in
+- [`scenic-prism-react`](https://www.npmjs.com/package/scenic-prism-react) — the
+  same renderer, on a canvas in a component
+
+## Licence
+
+[PolyForm Noncommercial 1.0.0](https://polyformproject.org/licenses/noncommercial/1.0.0).
+
+Free for any **noncommercial** purpose — personal projects, study, experiments,
+hobby and amateur work, teaching, and use by charities, schools, universities,
+public research bodies, public health and safety organisations and government,
+whoever is funding them. Change it, build on it and redistribute it on those
+same terms, passing on the licence and its `Required Notice:` line with any copy.
+
+**Commercial use needs a separate licence.** If you want to use `scenic-prism`
+in or around a commercial product, ask via
+[the repository](https://github.com/jamesporter/Scenic-Draft).
+
+The terms in full are in the `LICENSE` file shipped inside this package, and
+explained in plain language at
+[scenic-prism.pages.dev/license](https://scenic-prism.pages.dev/license).

package/dist/image.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The image half of the package: what a file extension means, and how the
+ * canvas's data URL becomes bytes on disk. Nothing here touches a browser, so
+ * it is all pure and directly testable.
+ */
+/** The encodings a browser canvas can produce, and this package can save. */
+export type ImageFormat = 'png' | 'jpeg' | 'webp';
+/** The MIME type `canvas.toDataURL()` wants for each of them. */
+export declare const MIME_TYPES: Readonly<Record<ImageFormat, string>>;
+/**
+ * The format an output path asks for, by its extension. Callers can always
+ * override it with `format`, which is what this falls back to being for a path
+ * whose extension says nothing.
+ */
+export declare function formatForPath(path: string): ImageFormat;
+/**
+ * Quality is meaningful to the lossy encoders only. PNG ignores it, so passing
+ * one alongside a `.png` is a mistake worth naming rather than silently
+ * dropping — a caller who set it believed it was doing something.
+ */
+export declare function checkQuality(format: ImageFormat, quality: number | undefined): void;
+/**
+ * The bytes behind a `data:` URL. `canvas.toDataURL()` is the only producer
+ * this ever sees, so the payload is always base64 — but a canvas asked for a
+ * format it cannot encode quietly returns a PNG instead, and the URL's own
+ * MIME type is the only place that shows. It is checked by the caller.
+ */
+export declare function decodeDataUrl(dataUrl: string): {
+    mimeType: string;
+    bytes: Buffer;
+};

package/dist/image.js

@@ -0,0 +1,68 @@
+/**
+ * The image half of the package: what a file extension means, and how the
+ * canvas's data URL becomes bytes on disk. Nothing here touches a browser, so
+ * it is all pure and directly testable.
+ */
+/** The MIME type `canvas.toDataURL()` wants for each of them. */
+export const MIME_TYPES = {
+    png: 'image/png',
+    jpeg: 'image/jpeg',
+    webp: 'image/webp',
+};
+/**
+ * File extensions, against the format they mean. `.jpg` and `.jpeg` are the
+ * same encoding; there is deliberately no default for anything else, because
+ * writing PNG bytes into a `.gif` a caller asked for is worse than saying so.
+ */
+const EXTENSIONS = {
+    '.png': 'png',
+    '.jpg': 'jpeg',
+    '.jpeg': 'jpeg',
+    '.webp': 'webp',
+};
+/**
+ * The format an output path asks for, by its extension. Callers can always
+ * override it with `format`, which is what this falls back to being for a path
+ * whose extension says nothing.
+ */
+export function formatForPath(path) {
+    const match = /\.[^./\\]+$/.exec(path);
+    const extension = match?.[0].toLowerCase() ?? '';
+    const format = EXTENSIONS[extension];
+    if (format)
+        return format;
+    throw new Error(`scenic-prism-playwright: cannot tell the image format of '${path}'. ` +
+        `Use one of ${Object.keys(EXTENSIONS).join(', ')}, or pass an explicit \`format\`.`);
+}
+/**
+ * Quality is meaningful to the lossy encoders only. PNG ignores it, so passing
+ * one alongside a `.png` is a mistake worth naming rather than silently
+ * dropping — a caller who set it believed it was doing something.
+ */
+export function checkQuality(format, quality) {
+    if (quality === undefined)
+        return;
+    if (format === 'png') {
+        throw new Error('scenic-prism-playwright: `quality` applies to jpeg and webp only — png is lossless.');
+    }
+    if (!(quality > 0 && quality <= 1)) {
+        throw new Error(`scenic-prism-playwright: \`quality\` must be in (0, 1], got ${quality}.`);
+    }
+}
+/**
+ * The bytes behind a `data:` URL. `canvas.toDataURL()` is the only producer
+ * this ever sees, so the payload is always base64 — but a canvas asked for a
+ * format it cannot encode quietly returns a PNG instead, and the URL's own
+ * MIME type is the only place that shows. It is checked by the caller.
+ */
+export function decodeDataUrl(dataUrl) {
+    const comma = dataUrl.indexOf(',');
+    const header = comma === -1 ? '' : dataUrl.slice(0, comma);
+    if (!header.startsWith('data:') || !header.endsWith(';base64')) {
+        throw new Error('scenic-prism-playwright: the canvas did not return a base64 data URL.');
+    }
+    return {
+        mimeType: header.slice('data:'.length, -';base64'.length),
+        bytes: Buffer.from(dataUrl.slice(comma + 1), 'base64'),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * scenic-prism-playwright — a `scenic-prism` scene, path-traced to an image
+ * file from Node.
+ *
+ * ```ts
+ * import { backgrounds, materials, sphere } from 'scenic-prism-fluent';
+ * import { renderToFile } from 'scenic-prism-playwright';
+ *
+ * await renderToFile(
+ *   { scene: sphere(1).paint(materials.chrome), background: backgrounds.dusk },
+ *   'renders/chrome.png',
+ *   { size: 1200, maxFrames: 900, seed: 7 },
+ * );
+ * ```
+ *
+ * Run it with anything that runs TypeScript — `tsx render.ts`, `node
+ * --experimental-strip-types`, or plain JavaScript. One call launches a
+ * headless Chromium, traces until the accumulation finishes, saves the file and
+ * shuts the browser down again.
+ *
+ * Four things are worth knowing before reading further.
+ *
+ * **It is the library's own renderer.** There is no second path tracer here and
+ * no shader of this package's own: the installed copy of `scenic-prism` is
+ * served to the page as ES modules and its `render()` does the work, so a saved
+ * image and the same scene on a web page come out of the same code.
+ *
+ * **The two big dependencies are peers.** `scenic-prism-fluent` — which carries
+ * `scenic-prism` — and `playwright` are the caller's to install and the
+ * caller's to version. The scenes handed in are built from the very copy of the
+ * library this then renders, and the browsers Playwright manages stay under the
+ * project's own control. The one thing it installs for itself is `sharp`, which
+ * is what draws a `margin` around a finished image — the browser has been shut
+ * by then, so there is nothing else left to draw it with.
+ *
+ * **It uses the GPU when the machine has one.** Path tracing in software is
+ * minutes where hardware is seconds, so a render asks for the graphics card and
+ * falls back to SwiftShader on the build container that has none. Pass
+ * `gpu: false` to rasterise in software everywhere, which is what makes the
+ * same scene and `seed` give the same pixels on every machine.
+ *
+ * **One browser, many images.** {@link renderToFile} and
+ * {@link renderToBuffer} open and close a browser around a single render.
+ * A script writing a folder of plates should {@link openStudio} instead and
+ * close it at the end — the launch is most of the cost of the first image.
+ */
+export { renderToBuffer, renderToFile } from './render.js';
+export type { HeadlessOptions } from './render.js';
+export { DEFAULT_BROWSER_ARGS, DEFAULT_TIMEOUT, GPU_BROWSER_ARGS, SOFTWARE_BROWSER_ARGS, launchPlan, openStudio, } from './studio.js';
+export type { AdapterReport, GpuPreference, RenderOptions, RenderedImage, RenderedImageData, SavedImage, Studio, StudioOptions, TraceOptions, } from './studio.js';
+export { MIME_TYPES } from './image.js';
+export type { ImageFormat } from './image.js';
+export type { MarginOptions } from './margin.js';

package/dist/index.js

@@ -0,0 +1,49 @@
+/**
+ * scenic-prism-playwright — a `scenic-prism` scene, path-traced to an image
+ * file from Node.
+ *
+ * ```ts
+ * import { backgrounds, materials, sphere } from 'scenic-prism-fluent';
+ * import { renderToFile } from 'scenic-prism-playwright';
+ *
+ * await renderToFile(
+ *   { scene: sphere(1).paint(materials.chrome), background: backgrounds.dusk },
+ *   'renders/chrome.png',
+ *   { size: 1200, maxFrames: 900, seed: 7 },
+ * );
+ * ```
+ *
+ * Run it with anything that runs TypeScript — `tsx render.ts`, `node
+ * --experimental-strip-types`, or plain JavaScript. One call launches a
+ * headless Chromium, traces until the accumulation finishes, saves the file and
+ * shuts the browser down again.
+ *
+ * Four things are worth knowing before reading further.
+ *
+ * **It is the library's own renderer.** There is no second path tracer here and
+ * no shader of this package's own: the installed copy of `scenic-prism` is
+ * served to the page as ES modules and its `render()` does the work, so a saved
+ * image and the same scene on a web page come out of the same code.
+ *
+ * **The two big dependencies are peers.** `scenic-prism-fluent` — which carries
+ * `scenic-prism` — and `playwright` are the caller's to install and the
+ * caller's to version. The scenes handed in are built from the very copy of the
+ * library this then renders, and the browsers Playwright manages stay under the
+ * project's own control. The one thing it installs for itself is `sharp`, which
+ * is what draws a `margin` around a finished image — the browser has been shut
+ * by then, so there is nothing else left to draw it with.
+ *
+ * **It uses the GPU when the machine has one.** Path tracing in software is
+ * minutes where hardware is seconds, so a render asks for the graphics card and
+ * falls back to SwiftShader on the build container that has none. Pass
+ * `gpu: false` to rasterise in software everywhere, which is what makes the
+ * same scene and `seed` give the same pixels on every machine.
+ *
+ * **One browser, many images.** {@link renderToFile} and
+ * {@link renderToBuffer} open and close a browser around a single render.
+ * A script writing a folder of plates should {@link openStudio} instead and
+ * close it at the end — the launch is most of the cost of the first image.
+ */
+export { renderToBuffer, renderToFile } from "./render.js";
+export { DEFAULT_BROWSER_ARGS, DEFAULT_TIMEOUT, GPU_BROWSER_ARGS, SOFTWARE_BROWSER_ARGS, launchPlan, openStudio, } from "./studio.js";
+export { MIME_TYPES } from "./image.js";

package/dist/library.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Walk `node_modules` upwards from a directory, the way Node's own resolver
+ * does, and return the root of the first `name` found. Deliberately not
+ * `require.resolve`: this package and the ones it looks for are ESM with an
+ * `exports` map that has no `require` condition, so CommonJS resolution cannot
+ * see them, and `import.meta.resolve` answers with an entry module rather than
+ * with the package root and its manifest — which is what has to be served.
+ */
+export declare function findPackageRoot(from: string, name: string): string | null;
+/**
+ * Where the installed `scenic-prism` lives. Looked for beside the fluent
+ * package first — that is the copy the caller's scenes are built with, and the
+ * one whose version the fluent package pins — and only then beside this one,
+ * for an install flat enough to hoist it.
+ */
+export declare function resolveLibraryRoot(): string;
+/**
+ * The module a browser should import for a package root, as a path relative to
+ * it. Read off the manifest the way a bundler would: the `import` condition of
+ * the main export first, then the legacy fields.
+ */
+export declare function browserEntry(root: string): string;
+/** Content types for the handful of things a package's `dist` holds. */
+export declare function contentType(path: string): string;
+/**
+ * Resolve a request path against the served root, refusing anything that
+ * climbs out of it. Nothing here is reachable from outside the browser this
+ * package launched, but a scene is data and data comes from somewhere, so the
+ * one place a path could be influenced is still checked.
+ */
+export declare function resolveServedFile(root: string, requestPath: string): string | null;