@push.rocks/smartbrowser 2.0.10 → 3.0.0

package/dist_ts_web/index.d.ts

@@ -0,0 +1,3 @@
+export { LiveBrowserCanvasRenderer } from './classes.livebrowsercanvasrenderer.js';
+export type * from './interfaces.livebrowsercanvas.js';
+export type { ILiveBrowserError, ILiveBrowserErrorEvent, ILiveBrowserFrame, ILiveBrowserFrameAcknowledgement, ILiveBrowserFrameAcknowledgementRequest, ILiveBrowserFrameEvent, ILiveBrowserInputBase, ILiveBrowserInsertTextInput, ILiveBrowserKeyInput, ILiveBrowserModifierState, ILiveBrowserMouseInput, ILiveBrowserScreencastMetadata, ILiveBrowserState, ILiveBrowserStateEvent, ILiveBrowserTabState, ILiveBrowserViewport, ILiveBrowserWheelInput, TLiveBrowserEvent, TLiveBrowserEventListener, TLiveBrowserImageFormat, TLiveBrowserStatus, TLiveBrowserTabStatus, } from '@push.rocks/smartpuppeteer';

package/dist_ts_web/index.js

@@ -0,0 +1,2 @@
+export { LiveBrowserCanvasRenderer } from './classes.livebrowsercanvasrenderer.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c193ZWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sd0NBQXdDLENBQUMifQ==

package/dist_ts_web/interfaces.livebrowsercanvas.d.ts

@@ -0,0 +1,29 @@
+import type { ILiveBrowserFrame, ILiveBrowserFrameAcknowledgement, ILiveBrowserFrameAcknowledgementRequest, ILiveBrowserInsertTextInput, ILiveBrowserKeyInput, ILiveBrowserMouseInput, ILiveBrowserState, ILiveBrowserViewport, ILiveBrowserWheelInput, TLiveBrowserEventListener } from '@push.rocks/smartpuppeteer';
+export interface ILiveBrowserCanvasClient {
+    getState(): ILiveBrowserState;
+    onEvent(listenerArg: TLiveBrowserEventListener): () => void;
+    acknowledgeFrame(requestArg: ILiveBrowserFrameAcknowledgementRequest): Promise<ILiveBrowserFrameAcknowledgement>;
+    setViewport(viewportArg: ILiveBrowserViewport): Promise<void>;
+    dispatchMouse(inputArg: ILiveBrowserMouseInput): Promise<void>;
+    dispatchWheel(inputArg: ILiveBrowserWheelInput): Promise<void>;
+    dispatchKey(inputArg: ILiveBrowserKeyInput): Promise<void>;
+    insertText(inputArg: ILiveBrowserInsertTextInput): Promise<void>;
+}
+export type TLiveBrowserCanvasErrorCode = 'frame_acknowledgement_failed' | 'frame_render_failed' | 'input_dispatch_failed' | 'input_queue_capacity_exceeded' | 'remote_browser_error' | 'renderer_callback_failed' | 'renderer_cleanup_failed' | 'viewport_update_failed';
+export interface ILiveBrowserCanvasError {
+    code: TLiveBrowserCanvasErrorCode;
+    message: string;
+    cause?: unknown;
+    frame?: ILiveBrowserFrame;
+}
+export interface ILiveBrowserCanvasRendererOptions {
+    canvas: HTMLCanvasElement;
+    client: ILiveBrowserCanvasClient;
+    focusTarget?: HTMLElement;
+    resizeTarget?: Element;
+    getDeviceScaleFactor?: () => number;
+    operationTimeoutMs?: number;
+    frameDecodeTimeoutMs?: number;
+    onError?: (errorArg: ILiveBrowserCanvasError) => void;
+    onFrameRendered?: (frameArg: ILiveBrowserFrame) => void;
+}

package/dist_ts_web/interfaces.livebrowsercanvas.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5saXZlYnJvd3NlcmNhbnZhcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3dlYi9pbnRlcmZhY2VzLmxpdmVicm93c2VyY2FudmFzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/license.md

@@ -0,0 +1,19 @@
+Copyright (c) 2016 Task Venture Capital GmbH <hello@task.vc>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,49 +1,56 @@
 {
   "name": "@push.rocks/smartbrowser",
-  "version": "2.0.10",
+  "version": "3.0.0",
   "description": "A simplified Puppeteer wrapper for easy automation and testing tasks.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
-  "scripts": {
-    "test": "(tstest test/ --web)",
-    "build": "(tsbuild --web --allowimplicitany)",
-    "buildDocs": "tsdoc"
+  "exports": {
+    ".": {
+      "import": "./dist_ts/index.js",
+      "types": "./dist_ts/index.d.ts"
+    },
+    "./web": {
+      "import": "./dist_ts_web/index.js",
+      "types": "./dist_ts_web/index.d.ts"
+    }
+  },
+  "engines": {
+    "node": ">=22.12.0"
   },
   "repository": {
     "type": "git",
     "url": "https://code.foss.global/push.rocks/smartbrowser.git"
   },
-  "author": "Lossless GmbH",
+  "author": "Task Venture Capital GmbH <hello@task.vc>",
   "license": "MIT",
   "bugs": {
-    "url": "https://gitlab.com/pushrocks/smartbrowser/issues"
+    "url": "https://code.foss.global/push.rocks/smartbrowser/issues"
   },
   "homepage": "https://code.foss.global/push.rocks/smartbrowser",
   "dependencies": {
-    "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartpdf": "^3.1.8",
-    "@push.rocks/smartpuppeteer": "^2.0.0",
-    "@push.rocks/smartunique": "^3.0.9"
+    "@push.rocks/smartdelay": "^3.1.0",
+    "@push.rocks/smartpdf": "^5.0.1",
+    "@push.rocks/smartpuppeteer": "^2.1.0",
+    "@push.rocks/smartunique": "^3.0.10"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.2.0",
-    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.90",
-    "@push.rocks/tapbundle": "^5.5.4",
-    "@types/node": "^22.10.4"
+    "@git.zone/tsbuild": "^4.4.2",
+    "@git.zone/tsrun": "^2.0.6",
+    "@git.zone/tstest": "^4.0.0",
+    "@types/node": "^26.1.2"
   },
   "private": false,
   "files": [
     "ts/**/*",
     "ts_web/**/*",
-    "dist/**/*",
     "dist_*/**/*",
     "dist_ts/**/*",
     "dist_ts_web/**/*",
     "assets/**/*",
     "cli.js",
-    "npmextra.json",
+    ".smartconfig.json",
+    "license.md",
     "readme.md"
   ],
   "browserslist": [
@@ -57,5 +64,10 @@
     "screenshot",
     "web scraping",
     "browser automation"
-  ]
-}
+  ],
+  "scripts": {
+    "test": "tstest test/",
+    "build": "tsbuild tsfolders",
+    "buildDocs": "tsdoc"
+  }
+}

package/readme.hints.md

@@ -1 +1,25 @@
- 
+# SmartBrowser Hints
+
+## Dependencies (as of 2026-08-05)
+- `@push.rocks/smartpdf` v5.x uses SmartPuppeteer 2.1/Puppeteer 25 browser types. `SmartPdf` remains lazy and starts only for PDF methods.
+- `@push.rocks/smartpuppeteer` v2.1 owns `LiveBrowserSession` and the canonical transport-neutral live browser contracts.
+- Tests import `@git.zone/tstest/tapbundle`; browser tests use the `.chromium.ts` suffix.
+- The Node.js entry requires Node.js 22.12 or newer. This repository uses pnpm 11.20 for development and release tooling.
+- Puppeteer `page.screenshot({ encoding: 'binary' })` returns `Uint8Array`, not `Buffer` - wrap with `Buffer.from()`
+
+## Build
+- `pnpm run build` uses `tsbuild tsfolders` and emits both `dist_ts` and `dist_ts_web`.
+- `@push.rocks/smartbrowser/web` must remain runtime-isolated from Puppeteer, SmartPDF, Buffer, and Node.js built-ins. Only type imports from SmartPuppeteer are allowed.
+- `pnpm test` runs Node and Chromium files through tstest 4.
+
+## Canvas Renderer Invariants
+- The client facade is transport-neutral. Authentication, authorization, binary wire encoding, session ownership, and egress policy belong to the consuming adapter.
+- Input always carries the identity of the actually displayed frame, never merely the newest state event.
+- Cached state may lag a new frame generation. A state identity ahead of the displayed frame invalidates it; same-identity metadata updates do not.
+- One frame may decode while only the newest subsequent frame waits. The renderer makes at most one acknowledgement request for each drawn, stale, superseded, failed, or shutdown-retired frame; failures and capacity exhaustion are reported and stop the renderer.
+- Renderer starts and explicit stops are serialized by run epoch. A renderer can restart after an explicit stop. Acknowledgement failures, input-release failures, capacity exhaustion, and client/decode timeouts terminally stop the instance because underlying work is not cancellable through the client interface; create a new renderer and client after those failures.
+- Repeated blur, visibility, and pointer-loss resets coalesce into one bounded reset operation.
+- Pressed input is retained until release succeeds, with one retry for transient release failures. Input remains blocked while a release is unresolved.
+- Resize uses a caller-supplied stable CSS element. Requests are latest-only and serialized; input is released before resizing and remains blocked until a frame meeting the target revision fence is drawn.
+- Intrinsic canvas dimensions come from encoded frame dimensions. Pointer coordinates map to the frame's logical CSS viewport.
+- Pointer and wheel listeners remain on the canvas. Keyboard and composition listeners use `focusTarget`, which defaults to the canvas. Call `insertText()` for text committed by an external IME or dedicated input control.

package/readme.md

@@ -1,114 +1,231 @@
 # @push.rocks/smartbrowser
-simplified puppeteer
+A simplified Puppeteer wrapper for easy browser automation, PDF generation, screenshots, and page evaluation.
+
+The package also provides an isolated browser-side entry at `@push.rocks/smartbrowser/web`. Its `LiveBrowserCanvasRenderer` displays SmartPuppeteer live-session frames in a canvas and maps local input back to transport-neutral browser commands without bundling Puppeteer or Node.js code into the web application.
+
+## Issue Reporting and Security
+
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
 
 ## Install
-To install `@push.rocks/smartbrowser`, use the following npm command:
+
+Install the package with pnpm:
 
 ```bash
-npm install @push.rocks/smartbrowser --save
+pnpm add @push.rocks/smartbrowser
 ```
 
-This will add `@push.rocks/smartbrowser` to your project's dependencies.
+The Node.js entry requires Node.js 22.12 or newer and a Chromium-compatible browser. It uses SmartPuppeteer 2.1, Puppeteer 25, and SmartPDF 5. SmartPuppeteer detects common local, CI, and container environments and configures Chromium accordingly.
 
 ## Usage
 
-`@push.rocks/smartbrowser` simplifies interactions with Puppeteer for tasks like generating PDFs or capturing screenshots from webpages. Below are examples illustrating how you can use `@push.rocks/smartbrowser` in your projects.
+`@push.rocks/smartbrowser` provides a high-level `SmartBrowser` class that wraps Puppeteer for common browser automation tasks: generating PDFs, capturing screenshots, and evaluating JavaScript on web pages.
 
 ### Getting Started
 
-First, import `SmartBrowser` from `@push.rocks/smartbrowser`:
+Import and initialize a `SmartBrowser` instance:
 
 ```typescript
 import { SmartBrowser } from '@push.rocks/smartbrowser';
-```
-
-Then, initialize and start the `SmartBrowser` instance:
 
-```typescript
 const smartBrowser = new SmartBrowser();
 await smartBrowser.start();
 ```
 
 ### Generating a PDF from a Webpage
 
-You can generate a PDF from any webpage URL. This can be particularly useful for generating reports, invoices, or snapshot captures of web content.
+Generate a full-page PDF from any URL. The result includes a `Buffer` with the PDF contents:
 
 ```typescript
-// Generate a PDF from a page
 const pdfResult = await smartBrowser.pdfFromPage('https://example.com');
-console.log(pdfResult.buffer); // This holds the PDF file's buffer
+console.log(pdfResult.buffer); // PDF file buffer
+console.log(pdfResult.name);   // Generated name identifier
 ```
 
+The PDF generation is powered by `@push.rocks/smartpdf`, which is lazily initialized on first use. This means the SmartPdf server is only started when you actually call `pdfFromPage()`, keeping resource usage minimal.
+
 ### Capturing a Screenshot of a Webpage
 
-Similarly, you can capture a screenshot of a webpage by passing the URL. This is useful for capturing the current state of a web application, for audits, or for keeping visual records.
+Capture a PNG screenshot of any webpage:
 
 ```typescript
-// Capture a screenshot from a page
 const screenshotResult = await smartBrowser.screenshotFromPage('https://example.com');
-console.log(screenshotResult.buffer); // This is the screenshot's buffer
+console.log(screenshotResult.buffer); // Screenshot buffer (PNG)
+console.log(screenshotResult.name);   // Short unique identifier
+console.log(screenshotResult.id);     // Identifier with extension
 ```
 
 ### Evaluating JavaScript on a Webpage
 
-`SmartBrowser` also allows you to evaluate JavaScript on the webpage. This can be useful for scraping data, testing web applications, or automating interactions with webpages.
+Run arbitrary JavaScript inside a page context and retrieve the result:
 
 ```typescript
-// Evaluate JavaScript on a page
-const pageTitle = await smartBrowser.evaluateOnPage('https://example.com', () => {
-  return document.title; // Gets the title of the page
+const pageTitle = await smartBrowser.evaluateOnPage('https://example.com', async () => {
+  return document.title;
 });
-console.log(pageTitle); // Logs the page title to the console
+console.log(pageTitle); // "Example Domain"
+```
+
+The `evaluateOnPage` method supports generic return types:
+
+```typescript
+const metrics = await smartBrowser.evaluateOnPage<{ width: number; height: number }>(
+  'https://example.com',
+  async () => {
+    return {
+      width: window.innerWidth,
+      height: window.innerHeight,
+    };
+  }
+);
+console.log(metrics.width, metrics.height);
 ```
 
+Pages are automatically closed after evaluation, even if an error occurs.
+
+### Accessing the Underlying Puppeteer Browser
+
+For advanced use cases, you can access the Puppeteer browser instance directly:
+
+```typescript
+const page = await smartBrowser.headlessBrowser.newPage();
+await page.goto('https://example.com');
+// ... custom Puppeteer operations
+await page.close();
+```
+
+You can also import the `smartpuppeteer` module directly for lower-level browser management:
+
+```typescript
+import { smartpuppeteer } from '@push.rocks/smartbrowser';
+
+const browser = await smartpuppeteer.getEnvAwareBrowserInstance();
+```
+
+## Live Browser Canvas
+
+Import the browser-only renderer from `@push.rocks/smartbrowser/web`. The Node.js root entry is intentionally separate and must not be imported into a frontend bundle.
+
+The renderer receives a caller-provided `ILiveBrowserCanvasClient`. An application adapter implements that interface using its authenticated transport and keeps the latest `ILiveBrowserState` available through `getState()`. SmartBrowser does not prescribe TypedSocket, WebSocket framing, base64 conversion, authentication, authorization, or session ownership.
+
+```typescript
+import {
+  LiveBrowserCanvasRenderer,
+  type ILiveBrowserCanvasClient,
+} from '@push.rocks/smartbrowser/web';
+
+export async function mountLiveBrowser(client: ILiveBrowserCanvasClient) {
+  const viewport = document.querySelector<HTMLElement>('[data-live-browser-viewport]')!;
+  const canvas = viewport.querySelector<HTMLCanvasElement>('canvas')!;
+
+  const renderer = new LiveBrowserCanvasRenderer({
+    canvas,
+    client,
+    // Observe a stable CSS-sized element, not the canvas backing bitmap.
+    resizeTarget: viewport,
+    onError: (error) => console.error(error.code, error.message),
+  });
+
+  await renderer.start();
+  return async () => {
+    // Stop the renderer before closing its transport so queued frames can be acknowledged.
+    await renderer.stop();
+  };
+}
+```
+
+A minimal host keeps CSS sizing independent from the canvas's encoded backing dimensions:
+
+```html
+<div data-live-browser-viewport style="width: 100%; height: 600px; overflow: hidden">
+  <canvas style="display: block; width: 100%; height: 100%"></canvas>
+</div>
+```
+
+`ILiveBrowserCanvasClient` exposes the renderer-facing subset of the canonical SmartPuppeteer live-session API:
+
+- Cached state and events: `getState()` and `onEvent()`
+- Frame flow control: `acknowledgeFrame()`
+- Viewport synchronization: `setViewport()`
+- Input: `dispatchMouse()`, `dispatchWheel()`, `dispatchKey()`, and `insertText()`
+
+The renderer keeps at most one frame decoding and one newest frame queued. It makes one acknowledgement attempt after a frame is drawn, deliberately dropped, found stale, or fails decoding. A failed or timed-out acknowledgement is reported through `onError` and terminally stops the renderer because frame flow control is no longer reliable. Acknowledgement capacity exhaustion also terminally stops the renderer. Input identity always comes from the frame actually displayed, so tab, generation, and viewport changes block stale clicks and keystrokes. Encoded `frame.width` and `frame.height` set the canvas backing bitmap, while pointer coordinates map through the displayed canvas rectangle into the frame's logical CSS viewport.
+
+Pointer and wheel input are captured from the canvas. Keyboard and best-effort `compositionend` input are captured from `focusTarget`, which defaults to the canvas and receives focus on pointer down. The renderer temporarily makes an unfocusable focus target focusable and restores its prior `tabindex` on stop. Applications with a dedicated text or IME control can call `renderer.insertText(text)` explicitly.
+
+When `resizeTarget` is supplied, resize updates are deduplicated, serialized, and fenced by viewport revision. The target must have stable CSS dimensions that do not depend on `canvas.width` or `canvas.height`; this prevents intrinsic canvas updates from causing resize feedback.
+
+`ILiveBrowserCanvasRendererOptions` supports:
+
+- `canvas` and `client`: required rendering and transport-adapter dependencies.
+- `focusTarget`: optional keyboard and composition event target; defaults to `canvas`.
+- `resizeTarget`: optional stable CSS-sized element observed for remote viewport updates.
+- `getDeviceScaleFactor`: optional scale provider; defaults to `window.devicePixelRatio` and is useful when the application controls remote scaling explicitly.
+- `operationTimeoutMs`: timeout for client acknowledgements, viewport updates, and input operations; defaults to 10 seconds. A timeout terminally stops the renderer because the underlying adapter operation cannot be cancelled through this interface.
+- `frameDecodeTimeoutMs`: image decode timeout; defaults to `operationTimeoutMs`. A timeout terminally stops the renderer and closes the decoded bitmap if it completes late.
+- `onError`: receives typed `ILiveBrowserCanvasError` values without interrupting renderer cleanup.
+- `onFrameRendered`: called after a current frame has been drawn.
+
+The renderer exposes `start()`, `stop()`, `insertText()`, `syncViewport()`, and the `isRunning` getter. `syncViewport()` requests a fresh measurement of the configured `resizeTarget`; it is a no-op when no target is configured or the renderer is stopped. An explicitly stopped renderer can be started again. After an acknowledgement failure, input-release failure, capacity exhaustion, or operation/decode timeout, create a new renderer and client instead; the failed instance rejects future `start()` calls because its non-cancellable underlying work may still affect the old client session. The `/web` entry also exports `ILiveBrowserCanvasClient`, `ILiveBrowserCanvasRendererOptions`, `ILiveBrowserCanvasError`, `TLiveBrowserCanvasErrorCode`, and the canonical SmartPuppeteer live-browser contract types.
+
+`LiveBrowserCanvasRenderer` is not a security boundary. The application adapter must authenticate viewers, authorize control, restrict navigation, enforce browser-session ownership, and apply network/egress policy before forwarding commands. The renderer displays webpage viewport pixels only. It does not provide native Chrome UI, audio, extensions, file transfer, clipboard, camera, microphone, or touch emulation.
+
 ### Shutting Down
 
-Once your tasks are complete, it's important to properly shut down the `SmartBrowser` instance to free up resources:
+Always stop the browser instance when done to free resources:
 
 ```typescript
 await smartBrowser.stop();
 ```
 
-### Full Example
+This cleanly shuts down the SmartPdf server (if it was initialized) and closes the browser.
 
-Combining the above steps, here's a full example of using `@push.rocks/smartbrowser` to generate a PDF and capture a screenshot of a webpage:
+### Full Example
 
 ```typescript
 import { SmartBrowser } from '@push.rocks/smartbrowser';
 
-async function generateWebAssets() {
+async function main() {
   const smartBrowser = new SmartBrowser();
   await smartBrowser.start();
 
+  // Generate a PDF
   const pdfResult = await smartBrowser.pdfFromPage('https://example.com');
-  console.log('PDF Generated:', pdfResult.buffer);
+  console.log('PDF size:', pdfResult.buffer.length, 'bytes');
+
+  // Take a screenshot
+  const screenshot = await smartBrowser.screenshotFromPage('https://example.com');
+  console.log('Screenshot size:', screenshot.buffer.length, 'bytes');
 
-  const screenshotResult = await smartBrowser.screenshotFromPage('https://example.com');
-  console.log('Screenshot Captured:', screenshotResult.buffer);
+  // Evaluate JavaScript
+  const title = await smartBrowser.evaluateOnPage('https://example.com', async () => {
+    return document.title;
+  });
+  console.log('Page title:', title);
 
   await smartBrowser.stop();
 }
 
-generateWebAssets();
+main();
 ```
 
-In this guide, you've learned how to use `@push.rocks/smartbrowser` for common browser automation tasks. Follow this pattern to incorporate web automation into your applications efficiently.
-
 ## License and Legal Information
 
-This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [license](license.md) file.
 
 **Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
 
 ### Trademarks
 
-This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.
+
+Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.
 
 ### Company Information
 
-Task Venture Capital GmbH  
-Registered at District court Bremen HRB 35230 HB, Germany
+Task Venture Capital GmbH<br>
+Registered at District Court Bremen HRB 35230 HB, Germany
 
-For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+For any legal inquiries or further information, please contact us via email at hello@task.vc.
 
 By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartbrowser',
-  version: '2.0.10',
+  version: '3.0.0',
   description: 'A simplified Puppeteer wrapper for easy automation and testing tasks.'
 }

package/ts/index.ts

@@ -6,8 +6,8 @@ import * as interfaces from './interfaces/index.js';
  * SmartBrowser
  */
 export class SmartBrowser {
-  public headlessBrowser: plugins.smartpuppeteer.puppeteer.Browser;
-  public smartpdf: plugins.smartpdf.SmartPdf;
+  public headlessBrowser!: plugins.smartpuppeteer.puppeteer.Browser;
+  public smartpdf: plugins.smartpdf.SmartPdf | null = null;
 
   /**
    * start the SmartBrowser instance
@@ -20,11 +20,12 @@ export class SmartBrowser {
   /**
    * ensure SmartPdf is initialized (lazy)
    */
-  private async ensureSmartPdf() {
+  private async ensureSmartPdf(): Promise<plugins.smartpdf.SmartPdf> {
     if (!this.smartpdf) {
       this.smartpdf = new plugins.smartpdf.SmartPdf();
       await this.smartpdf.start(this.headlessBrowser);
     }
+    return this.smartpdf;
   }
 
   /**
@@ -43,8 +44,8 @@ export class SmartBrowser {
    * @param urlArg
    */
   public async pdfFromPage(urlArg: string): Promise<plugins.smartpdf.IPdf> {
-    await this.ensureSmartPdf();
-    const result = await this.smartpdf.getFullWebsiteAsSinglePdf(urlArg);
+    const smartpdf = await this.ensureSmartPdf();
+    const result = await smartpdf.getFullWebsiteAsSinglePdf(urlArg);
     return result;
   }
 
@@ -58,9 +59,10 @@ export class SmartBrowser {
     await page.goto(urlArg, {
       waitUntil: 'networkidle2',
     });
-    const screenshotBuffer = (await page.screenshot({
+    const screenshotResult = await page.screenshot({
       encoding: 'binary',
-    })) as Buffer;
+    });
+    const screenshotBuffer = Buffer.from(screenshotResult);
     await page.close();
     return {
       name: pageId,
@@ -89,4 +91,4 @@ export class SmartBrowser {
 }
 
 import { smartpuppeteer } from './smartbrowser.plugins.js';
-export { smartpuppeteer };
+export { smartpuppeteer };

package/ts_web/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartbrowser',
+  version: '3.0.0',
+  description: 'A simplified Puppeteer wrapper for easy automation and testing tasks.'
+}