@e2e-dev/lightpanda 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,5 @@
+@e2e-dev/lightpanda
+Copyright 2026 TesterArmy, Inc.
+
+This product includes software developed at TesterArmy, Inc.
+(https://tester.army).

package/README.md

@@ -1,3 +1,41 @@
-# Temporary Holding Version
+# @e2e-dev/lightpanda
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[Lightpanda](https://lightpanda.io), the open-source headless browser, for
+[`e2e`](https://www.npmjs.com/package/e2e): `web({ browser: lightpanda() })`
+runs a web target in a `lightpanda serve` the provider starts for each
+worker slot and stops with the run.
+
+## Install
+
+```bash
+npm install --save-dev @e2e-dev/lightpanda
+brew install lightpanda-io/browser/lightpanda
+```
+
+## Usage
+
+```ts title="e2e.config.ts"
+import type { E2EConfig } from 'e2e';
+import { web } from '@e2e-dev/web';
+import { lightpanda } from '@e2e-dev/lightpanda';
+
+export default {
+  targets: [{ engine: web({ browser: lightpanda({ loadResources: ['iframe'] }) }), app: { url: 'http://localhost:3000' } }],
+  workers: 4,
+} satisfies E2EConfig;
+```
+
+The binary comes from `binary`, `LIGHTPANDA_PATH` in the run's environment,
+or `lightpanda` on `PATH`, `~/.lightpanda`, or `~/.local/bin`.
+`loadResources` passes `--load-resources` for `iframe`, `image`, and
+`stylesheet`; `args` adds any other `serve` flag. A server already running,
+such as the Docker image in CI, is a `web({ connect })` target instead.
+
+Lightpanda has no layout engine: locators, assertions, and agent steps on
+the accessibility tree work, while drags, dialogs, downloads, scrolling,
+and session restore do not. The full list lives at
+[e2e.tester.army/docs/integrations/lightpanda](https://e2e.tester.army/docs/integrations/lightpanda).
+
+## License
+
+Apache-2.0

package/dist/.build.json

@@ -0,0 +1 @@
+{"version":"0.0.0"}

package/dist/binary.d.ts

@@ -0,0 +1,8 @@
+/** Where the `lightpanda` binary is when the config does not say. */
+/**
+ * The binary to start: `LIGHTPANDA_PATH` when set, else `lightpanda` on
+ * `PATH`, then the places the install guides and agent-browser put it,
+ * `~/.lightpanda/lightpanda` and `~/.local/bin/lightpanda`. Throws, naming
+ * the install page and `LIGHTPANDA_PATH`, when none exists.
+ */
+export declare function findBinary(env: Readonly<Record<string, string | undefined>>): string;

package/dist/binary.js

@@ -0,0 +1,38 @@
+/** Where the `lightpanda` binary is when the config does not say. */
+import { accessSync, constants, statSync } from 'node:fs';
+import path from 'node:path';
+const INSTALL_URL = 'https://lightpanda.io/docs/open-source/installation';
+const NAME = 'lightpanda';
+const PATH_VARIABLE = 'LIGHTPANDA_PATH';
+/**
+ * The binary to start: `LIGHTPANDA_PATH` when set, else `lightpanda` on
+ * `PATH`, then the places the install guides and agent-browser put it,
+ * `~/.lightpanda/lightpanda` and `~/.local/bin/lightpanda`. Throws, naming
+ * the install page and `LIGHTPANDA_PATH`, when none exists.
+ */
+export function findBinary(env) {
+    const named = env[PATH_VARIABLE]?.trim();
+    if (named !== undefined && named !== '')
+        return named;
+    const onPath = (env['PATH'] ?? '').split(path.delimiter).filter((dir) => dir !== '');
+    const home = env['HOME'] ?? env['USERPROFILE'];
+    const candidates = [
+        ...onPath.map((dir) => path.join(dir, NAME)),
+        ...(home === undefined ? [] : [path.join(home, '.lightpanda', NAME), path.join(home, '.local', 'bin', NAME)]),
+    ];
+    const found = candidates.find(isExecutable);
+    if (found === undefined) {
+        throw new Error(`lightpanda is not on PATH, in ~/.lightpanda, or in ~/.local/bin; install it (${INSTALL_URL}) or set ${PATH_VARIABLE}`);
+    }
+    return found;
+}
+/** A regular file the process may execute; a directory of that name on `PATH` is skipped. */
+function isExecutable(file) {
+    try {
+        accessSync(file, constants.X_OK);
+        return statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `@e2e-dev/lightpanda` public surface: `lightpanda()`, a browser provider
+ * that starts and stops Lightpanda CDP servers for `@e2e-dev/web`.
+ */
+export { lightpanda } from './provider.ts';
+export type { LightpandaOptions } from './provider.ts';
+export type { LightpandaResource } from './server.ts';

package/dist/index.js

@@ -0,0 +1,5 @@
+/**
+ * `@e2e-dev/lightpanda` public surface: `lightpanda()`, a browser provider
+ * that starts and stops Lightpanda CDP servers for `@e2e-dev/web`.
+ */
+export { lightpanda } from './provider.js';

package/dist/provider.d.ts

@@ -0,0 +1,24 @@
+/** Lightpanda as a `BrowserProvider` for the web engine: one `lightpanda serve` per lease. */
+import type { BrowserProvider } from '@e2e-dev/web';
+import { type LightpandaResource } from './server.ts';
+export interface LightpandaOptions {
+    /**
+     * The `lightpanda` binary to start: a path, or a name on `PATH`. Default
+     * `LIGHTPANDA_PATH` from the run's environment, else `lightpanda` on
+     * `PATH`, `~/.lightpanda/lightpanda`, or `~/.local/bin/lightpanda`.
+     */
+    readonly binary?: string | undefined;
+    /** Sub-resources the server fetches (`iframe`, `image`, `stylesheet`), which Lightpanda skips by default. */
+    readonly loadResources?: readonly LightpandaResource[] | undefined;
+    /** Further `lightpanda serve` flags, after `--host`, `--port`, and `--load-resources`. */
+    readonly args?: readonly string[] | undefined;
+}
+/**
+ * Lightpanda browsers for `web({ browser: lightpanda() })`: one
+ * `lightpanda serve` per worker slot, started on a free port when the
+ * engine asks and stopped when it gives the lease back. Worker scope only:
+ * Lightpanda does not expose the default context identity a per-attempt
+ * lease reattaches by. A server already running is a `web({ connect })`
+ * target, not a provider.
+ */
+export declare function lightpanda(options?: LightpandaOptions): BrowserProvider;

package/dist/provider.js

@@ -0,0 +1,34 @@
+/** Lightpanda as a `BrowserProvider` for the web engine: one `lightpanda serve` per lease. */
+import { findBinary } from './binary.js';
+import { serve } from './server.js';
+/** How long a server gets to answer on its port before the lease fails. */
+const STARTUP_TIMEOUT_MS = 10_000;
+/** How long a released server gets to exit on SIGTERM before SIGKILL. */
+const STOP_GRACE_MS = 5_000;
+/**
+ * Lightpanda browsers for `web({ browser: lightpanda() })`: one
+ * `lightpanda serve` per worker slot, started on a free port when the
+ * engine asks and stopped when it gives the lease back. Worker scope only:
+ * Lightpanda does not expose the default context identity a per-attempt
+ * lease reattaches by. A server already running is a `web({ connect })`
+ * target, not a provider.
+ */
+export function lightpanda(options = {}) {
+    const { loadResources = [], args = [] } = options;
+    // `release` gets back the object `acquire` returned, on the side that acquired it.
+    const servers = new WeakMap();
+    return {
+        name: 'lightpanda',
+        async acquire(request) {
+            const binary = options.binary ?? findBinary(request.env);
+            const server = await serve({ binary, env: request.env, loadResources, args, startupTimeoutMs: STARTUP_TIMEOUT_MS, signal: request.signal });
+            request.log(`lightpanda ${server.version} at ${server.cdpEndpoint}`);
+            const lease = { id: server.cdpEndpoint, cdpEndpoint: server.cdpEndpoint };
+            servers.set(lease, server);
+            return lease;
+        },
+        async release(lease) {
+            await servers.get(lease)?.stop(STOP_GRACE_MS);
+        },
+    };
+}

package/dist/server.d.ts

@@ -0,0 +1,36 @@
+/**
+ * One `lightpanda serve` process: started on a free port, awaited until its
+ * CDP server answers, stopped on release. The runner's managed-process
+ * module does the same for app commands but is not part of `e2e/engine`,
+ * so the process-group handling is mirrored here.
+ */
+/** A sub-resource `lightpanda serve --load-resources` fetches; none are fetched by default. */
+export type LightpandaResource = 'iframe' | 'image' | 'stylesheet';
+export interface ServeOptions {
+    /** The binary to run, as `spawn` resolves it: a path, or a name on `env`'s `PATH`. */
+    readonly binary: string;
+    /** The run's environment, which the server starts in. */
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly loadResources: readonly LightpandaResource[];
+    /** Further `serve` flags, after the ones the provider sets. */
+    readonly args: readonly string[];
+    /** How long the server gets to answer before the start fails. */
+    readonly startupTimeoutMs: number;
+    readonly signal: AbortSignal;
+}
+export interface LightpandaServer {
+    readonly cdpEndpoint: string;
+    /** `Lightpanda-Version` from `/json/version`, or `unknown` for a build that reports none. */
+    readonly version: string;
+    /** Ends the process: SIGTERM, then SIGKILL after `graceMs` if it is still running. Resolves once it exited. */
+    stop(graceMs: number): Promise<void>;
+}
+/**
+ * Starts `lightpanda serve` on a free loopback port and resolves once
+ * `/json/version` answers. The process runs in its own process group so a
+ * terminal Ctrl-C reaches the runner, which owns the interrupt, and not the
+ * browser; `stop` signals the group. Rejects, with the process ended, when
+ * it exits first (its stderr in the message), when `startupTimeoutMs`
+ * passes, or when `signal` aborts; either way the port is polled no longer.
+ */
+export declare function serve(options: ServeOptions): Promise<LightpandaServer>;

package/dist/server.js

@@ -0,0 +1,137 @@
+/**
+ * One `lightpanda serve` process: started on a free port, awaited until its
+ * CDP server answers, stopped on release. The runner's managed-process
+ * module does the same for app commands but is not part of `e2e/engine`,
+ * so the process-group handling is mirrored here.
+ */
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:net';
+const HOST = '127.0.0.1';
+const POLL_MS = 50;
+const PROBE_TIMEOUT_MS = 500;
+/** Stderr kept for the error of a start that fails. */
+const STDERR_CAP = 64 * 1024;
+/**
+ * Starts `lightpanda serve` on a free loopback port and resolves once
+ * `/json/version` answers. The process runs in its own process group so a
+ * terminal Ctrl-C reaches the runner, which owns the interrupt, and not the
+ * browser; `stop` signals the group. Rejects, with the process ended, when
+ * it exits first (its stderr in the message), when `startupTimeoutMs`
+ * passes, or when `signal` aborts; either way the port is polled no longer.
+ */
+export async function serve(options) {
+    const port = await freePort();
+    const args = [
+        'serve',
+        '--host',
+        HOST,
+        '--port',
+        String(port),
+        ...options.loadResources.flatMap((resource) => ['--load-resources', resource]),
+        ...options.args,
+    ];
+    const child = spawn(options.binary, args, { env: options.env, detached: process.platform !== 'win32', stdio: ['ignore', 'ignore', 'pipe'] });
+    const stderr = captureStderr(child);
+    const exitReason = new Promise((resolve) => {
+        child.once('error', (cause) => resolve(`could not start ${options.binary}: ${cause.message}`));
+        child.once('exit', (code, signal) => {
+            const tail = stderr().trim();
+            resolve(`${options.binary} exited with ${signal ?? `code ${code}`} before its CDP server answered${tail === '' ? '' : `:\n${tail}`}`);
+        });
+    });
+    const cdpEndpoint = `ws://${HOST}:${port}/`;
+    const polling = new AbortController();
+    try {
+        const version = await Promise.race([
+            waitForVersion(`http://${HOST}:${port}/json/version`, options.startupTimeoutMs, AbortSignal.any([options.signal, polling.signal])),
+            exitReason.then((reason) => {
+                throw new Error(reason);
+            }),
+        ]);
+        return { cdpEndpoint, version, stop: (graceMs) => stop(child, graceMs) };
+    }
+    catch (cause) {
+        await stop(child, 1_000);
+        throw cause;
+    }
+    finally {
+        polling.abort();
+    }
+}
+/** Collects the child's stderr up to the cap; the returned function reads what was kept. */
+function captureStderr(child) {
+    const chunks = [];
+    let size = 0;
+    child.stderr?.on('data', (chunk) => {
+        if (size >= STDERR_CAP)
+            return;
+        chunks.push(chunk);
+        size += chunk.length;
+    });
+    return () => Buffer.concat(chunks).toString('utf8');
+}
+/** Polls `url` until it answers with JSON, resolving to its `Lightpanda-Version`; the caller races it against the process exiting. */
+async function waitForVersion(url, timeoutMs, signal) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        if (signal.aborted)
+            throw new Error('cancelled before the CDP server answered');
+        if (Date.now() > deadline)
+            throw new Error(`the CDP server did not answer on ${url} within ${timeoutMs}ms`);
+        try {
+            const response = await fetch(url, { signal: AbortSignal.any([signal, AbortSignal.timeout(PROBE_TIMEOUT_MS)]) });
+            if (response.ok) {
+                const body = await response.json();
+                const version = typeof body === 'object' && body !== null && 'Lightpanda-Version' in body ? body['Lightpanda-Version'] : undefined;
+                return typeof version === 'string' ? version : 'unknown';
+            }
+        }
+        catch {
+            // Not listening yet.
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+    }
+}
+/** Signals the process group, then kills it after the grace period; resolves once the process exited. */
+function stop(child, graceMs) {
+    if (child.exitCode !== null || child.signalCode !== null || child.pid === undefined)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => signalProcessGroup(child, 'SIGKILL'), graceMs);
+        child.once('exit', () => {
+            clearTimeout(timer);
+            resolve();
+        });
+        signalProcessGroup(child, 'SIGTERM');
+    });
+}
+/**
+ * Sends `signal` to the whole process group behind `child` (the child alone
+ * on Windows, which has no process groups); a group already gone is fine.
+ */
+function signalProcessGroup(child, signal) {
+    const pid = child.pid;
+    if (pid === undefined)
+        return;
+    try {
+        if (process.platform !== 'win32')
+            process.kill(-pid, signal);
+        else
+            child.kill(signal);
+    }
+    catch {
+        // process already gone
+    }
+}
+/** A loopback port nothing listens on right now. */
+function freePort() {
+    return new Promise((resolve, reject) => {
+        const probe = createServer();
+        probe.once('error', reject);
+        probe.listen(0, HOST, () => {
+            const address = probe.address();
+            const port = typeof address === 'object' && address !== null ? address.port : undefined;
+            probe.close(() => (port === undefined ? reject(new Error('no free port')) : resolve(port)));
+        });
+    });
+}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "@e2e-dev/lightpanda",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.0",
+  "description": "Lightpanda browsers for e2e: run web targets in the open-source headless browser, started and stopped per run",
+  "keywords": [
+    "e2e",
+    "end-to-end",
+    "testing",
+    "ai-testing",
+    "lightpanda",
+    "headless-browser",
+    "browser-automation",
+    "cdp"
+  ],
+  "license": "Apache-2.0",
+  "contributors": [
+    "Oskar Kwaśniewski <oskar@tester.army>",
+    "Szymon Rybczak <szymon@tester.army>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tester-army/e2e.git",
+    "directory": "packages/lightpanda"
+  },
+  "bugs": {
+    "url": "https://github.com/tester-army/e2e/issues"
+  },
+  "homepage": "https://github.com/tester-army/e2e/tree/main/packages/lightpanda#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public",
+    "tag": "latest"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "NOTICE"
+  ],
+  "peerDependencies": {
+    "@e2e-dev/web": ">=0.11.0 <1",
+    "e2e": ">=0.15.0 <1"
+  },
+  "devDependencies": {
+    "@e2e-dev/web": "0.15.1",
+    "@types/node": "26.6.2",
+    "e2e": "0.21.1",
+    "typescript": "7.0.2",
+    "vitest": "5.0.1"
+  },
+  "engines": {
+    "node": "^22.22.3 || >=24.8.0"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc --project tsconfig.build.json && node ../../scripts/stamp-dist.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:unit": "vitest run tests/unit"
+  }
 }