@lunora/browser 0.0.0 → 1.0.0-alpha.1

package/dist/index.d.mts

@@ -0,0 +1,171 @@
+/**
+* Structural projection of the Cloudflare **Browser Rendering** binding
+* (`env.BROWSER`). The binding is a `Fetcher` under the hood — `@cloudflare/playwright`
+* drives it via `launch(env.BROWSER)`. Declared locally (an empty structural
+* marker) so unit tests can pass a plain-object double and the real binding
+* satisfies the same shape without importing `@cloudflare/workers-types` into
+* the public surface. See https://developers.cloudflare.com/browser-rendering/.
+*
+* It is intentionally opaque: callers never touch the binding directly, they
+* hand it to {@link LunoraBrowserOptions.binding} and the Playwright layer
+* consumes it. Typed as a non-empty marker so an arbitrary value (e.g. `{}`)
+* doesn't silently type-check where a binding is required.
+*/
+interface BrowserBindingLike {
+  readonly fetch?: (...args: never[]) => unknown;
+}
+/**
+* Minimal projection of a Playwright `Page` — just the methods the helpers drive.
+* Declared structurally so a test can inject a plain stub instead of a real
+* headless page (which needs workerd + the Browser Rendering binding).
+*/
+interface PageLike {
+  /** Return the page's serialized HTML after the navigation settles. */
+  content: () => Promise<string>;
+  /** Run a function in the page context and return its (serializable) result. */
+  evaluate: <T>(function_: (...args: never[]) => T) => Promise<T>;
+  /** Navigate to a URL; resolves once the configured wait condition is met. */
+  goto: (url: string, options?: {
+    timeout?: number;
+    waitUntil?: string;
+  }) => Promise<unknown>;
+  /** Render the page to a PDF buffer. */
+  pdf: (options?: Record<string, unknown>) => Promise<Uint8Array>;
+  /** Render the page to a PNG/JPEG buffer. */
+  screenshot: (options?: Record<string, unknown>) => Promise<Uint8Array>;
+  /** Constrain the page viewport (a hard cap so a hostile page can't pin the worker). */
+  setViewportSize?: (viewport: {
+    height: number;
+    width: number;
+  }) => Promise<void>;
+}
+/**
+* Minimal projection of a Playwright `BrowserContext`. Only `newPage` is used;
+* declared structurally for the same test-double reason as {@link PageLike}.
+*/
+interface BrowserContextLike {
+  newPage: () => Promise<PageLike>;
+}
+/**
+* Minimal projection of a Playwright `Browser` (the value `launch` resolves to).
+* Only `newContext`/`close` are used; declared structurally for the same
+* test-double reason as {@link PageLike}.
+*/
+interface BrowserLike {
+  close: () => Promise<void>;
+  newContext: () => Promise<BrowserContextLike>;
+}
+/**
+* Structural projection of `@cloudflare/playwright`'s `launch` export
+* (`import { launch } from "@cloudflare/playwright"`). Injected via
+* {@link LunoraBrowserOptions.launch} so the factory never imports
+* `@cloudflare/playwright` at module top — that keeps the heavy optional peer
+* dep out of the bundle for apps that never screenshot, and lets tests pass a
+* fake. Calling it with the Browser Rendering binding resolves a {@link BrowserLike}.
+*/
+type BrowserLaunchLike = (binding: BrowserBindingLike, options?: Record<string, unknown>) => Promise<BrowserLike>;
+/** Options shared by the page-driving helpers ({@link Browser.screenshot} etc.). */
+interface NavigateOptions {
+  /**
+  * Hard timeout in milliseconds for the navigation + operation. Clamped to a
+  * sane ceiling so a hung/hostile page can't pin the worker. Default 30000.
+  */
+  timeoutMs?: number;
+  /**
+  * Playwright navigation wait condition. Playwright's set differs from
+  * Puppeteer's: `load`, `domcontentloaded`, `networkidle`, `commit`.
+  * Default `load`.
+  */
+  waitUntil?: "commit" | "domcontentloaded" | "load" | "networkidle";
+}
+/** Options for {@link Browser.screenshot}. */
+interface ScreenshotOptions extends NavigateOptions {
+  /** Capture the full scrollable page rather than just the viewport. */
+  fullPage?: boolean;
+  /** Image encoding. Default `png`. */
+  type?: "jpeg" | "png";
+  /**
+  * Viewport size. Each dimension is hard-capped (see the factory's
+  * `MAX_VIEWPORT_*`) so a caller can't request a multi-million-pixel render.
+  */
+  viewport?: {
+    height: number;
+    width: number;
+  };
+}
+/** Options for {@link Browser.pdf}. */
+interface PdfOptions extends NavigateOptions {
+  /** Paper format (`A4`, `Letter`, …) forwarded to Playwright. */
+  format?: string;
+  /** Print background graphics. Default `false`. */
+  printBackground?: boolean;
+  /**
+  * Viewport used while laying out the page before printing. Hard-capped like
+  * {@link ScreenshotOptions.viewport}.
+  */
+  viewport?: {
+    height: number;
+    width: number;
+  };
+}
+interface LunoraBrowserOptions {
+  /**
+  * Opt out of the SSRF guard that, by default, refuses to navigate to a
+  * private / internal / loopback / link-local host (RFC1918, `127.0.0.0/8`,
+  * `169.254.0.0/16` incl. the cloud-metadata address, CGNAT, IPv6 ULA/
+  * link-local, and `localhost` / `*.internal` / `*.local` literals). Leave it
+  * `false` (the default) unless every caller-supplied URL is trusted — e.g.
+  * you deliberately drive the browser at an internal service reachable through
+  * a Cloudflare Tunnel / private-network binding. Setting it `true` re-opens
+  * the SSRF surface, so never combine it with caller-controlled URLs.
+  */
+  allowPrivateTargets?: boolean;
+  /** The Cloudflare Browser Rendering binding (`env.BROWSER`). Required. */
+  binding: BrowserBindingLike;
+  /**
+  * The `@cloudflare/playwright` `launch` function. Injected rather than
+  * imported at module top so the optional peer dep stays out of the bundle
+  * for non-browser apps and tests can pass a double. The generated worker
+  * passes the real function; omitting it makes the helper throw on first use
+  * with a clear "install `@cloudflare/playwright`" error.
+  */
+  launch?: BrowserLaunchLike;
+  /**
+  * Default navigation timeout (ms) applied when a per-call `timeoutMs` is not
+  * given. Clamped to the factory's `MAX_TIMEOUT_MS`. Default 30000.
+  */
+  timeoutMs?: number;
+}
+/**
+* The `ctx.browser` surface — Cloudflare Browser Rendering driven through
+* `@cloudflare/playwright`. **Action-only**: every method performs
+* non-deterministic network I/O (it navigates a real headless browser to a
+* URL), so codegen wires it onto `ActionCtx` exclusively — never `QueryCtx`/
+* `MutationCtx` — exactly like `ctx.ai` / `ctx.fetch`. Each helper launches a
+* browser, opens a context + page, navigates, performs the op, and always
+* closes the browser in a `finally` (a leaked session is billed and
+* rate-limited).
+*/
+interface Browser {
+  /** Serialized HTML of `url` after navigation settles. */
+  content: (url: string, options?: NavigateOptions) => Promise<string>;
+  /**
+  * Low-level escape hatch: launch a raw Playwright `Browser` and hand it to
+  * `fn` (e.g. for multi-page flows or APIs not surfaced here). The browser is
+  * **always closed** when `fn` resolves or throws — do not retain references
+  * to it past the callback.
+  */
+  launch: <T>(function_: (browser: BrowserLike) => Promise<T>) => Promise<T>;
+  /** Render `url` to a PDF buffer. */
+  pdf: (url: string, options?: PdfOptions) => Promise<Uint8Array>;
+  /**
+  * Navigate to `url`, run `fn` inside the page context, and return its
+  * (serializable) result. `fn` runs in the browser, not the worker — it
+  * cannot close over worker-side variables.
+  */
+  scrape: <T>(url: string, function_: (...args: never[]) => T, options?: NavigateOptions) => Promise<T>;
+  /** Render `url` to an image buffer (PNG by default). */
+  screenshot: (url: string, options?: ScreenshotOptions) => Promise<Uint8Array>;
+}
+declare const createBrowser: (options: LunoraBrowserOptions) => Browser;
+export { type Browser, type BrowserBindingLike, type BrowserContextLike, type BrowserLaunchLike, type BrowserLike, type LunoraBrowserOptions, type NavigateOptions, type PageLike, type PdfOptions, type ScreenshotOptions, createBrowser };

package/dist/index.d.ts

@@ -0,0 +1,171 @@
+/**
+* Structural projection of the Cloudflare **Browser Rendering** binding
+* (`env.BROWSER`). The binding is a `Fetcher` under the hood — `@cloudflare/playwright`
+* drives it via `launch(env.BROWSER)`. Declared locally (an empty structural
+* marker) so unit tests can pass a plain-object double and the real binding
+* satisfies the same shape without importing `@cloudflare/workers-types` into
+* the public surface. See https://developers.cloudflare.com/browser-rendering/.
+*
+* It is intentionally opaque: callers never touch the binding directly, they
+* hand it to {@link LunoraBrowserOptions.binding} and the Playwright layer
+* consumes it. Typed as a non-empty marker so an arbitrary value (e.g. `{}`)
+* doesn't silently type-check where a binding is required.
+*/
+interface BrowserBindingLike {
+  readonly fetch?: (...args: never[]) => unknown;
+}
+/**
+* Minimal projection of a Playwright `Page` — just the methods the helpers drive.
+* Declared structurally so a test can inject a plain stub instead of a real
+* headless page (which needs workerd + the Browser Rendering binding).
+*/
+interface PageLike {
+  /** Return the page's serialized HTML after the navigation settles. */
+  content: () => Promise<string>;
+  /** Run a function in the page context and return its (serializable) result. */
+  evaluate: <T>(function_: (...args: never[]) => T) => Promise<T>;
+  /** Navigate to a URL; resolves once the configured wait condition is met. */
+  goto: (url: string, options?: {
+    timeout?: number;
+    waitUntil?: string;
+  }) => Promise<unknown>;
+  /** Render the page to a PDF buffer. */
+  pdf: (options?: Record<string, unknown>) => Promise<Uint8Array>;
+  /** Render the page to a PNG/JPEG buffer. */
+  screenshot: (options?: Record<string, unknown>) => Promise<Uint8Array>;
+  /** Constrain the page viewport (a hard cap so a hostile page can't pin the worker). */
+  setViewportSize?: (viewport: {
+    height: number;
+    width: number;
+  }) => Promise<void>;
+}
+/**
+* Minimal projection of a Playwright `BrowserContext`. Only `newPage` is used;
+* declared structurally for the same test-double reason as {@link PageLike}.
+*/
+interface BrowserContextLike {
+  newPage: () => Promise<PageLike>;
+}
+/**
+* Minimal projection of a Playwright `Browser` (the value `launch` resolves to).
+* Only `newContext`/`close` are used; declared structurally for the same
+* test-double reason as {@link PageLike}.
+*/
+interface BrowserLike {
+  close: () => Promise<void>;
+  newContext: () => Promise<BrowserContextLike>;
+}
+/**
+* Structural projection of `@cloudflare/playwright`'s `launch` export
+* (`import { launch } from "@cloudflare/playwright"`). Injected via
+* {@link LunoraBrowserOptions.launch} so the factory never imports
+* `@cloudflare/playwright` at module top — that keeps the heavy optional peer
+* dep out of the bundle for apps that never screenshot, and lets tests pass a
+* fake. Calling it with the Browser Rendering binding resolves a {@link BrowserLike}.
+*/
+type BrowserLaunchLike = (binding: BrowserBindingLike, options?: Record<string, unknown>) => Promise<BrowserLike>;
+/** Options shared by the page-driving helpers ({@link Browser.screenshot} etc.). */
+interface NavigateOptions {
+  /**
+  * Hard timeout in milliseconds for the navigation + operation. Clamped to a
+  * sane ceiling so a hung/hostile page can't pin the worker. Default 30000.
+  */
+  timeoutMs?: number;
+  /**
+  * Playwright navigation wait condition. Playwright's set differs from
+  * Puppeteer's: `load`, `domcontentloaded`, `networkidle`, `commit`.
+  * Default `load`.
+  */
+  waitUntil?: "commit" | "domcontentloaded" | "load" | "networkidle";
+}
+/** Options for {@link Browser.screenshot}. */
+interface ScreenshotOptions extends NavigateOptions {
+  /** Capture the full scrollable page rather than just the viewport. */
+  fullPage?: boolean;
+  /** Image encoding. Default `png`. */
+  type?: "jpeg" | "png";
+  /**
+  * Viewport size. Each dimension is hard-capped (see the factory's
+  * `MAX_VIEWPORT_*`) so a caller can't request a multi-million-pixel render.
+  */
+  viewport?: {
+    height: number;
+    width: number;
+  };
+}
+/** Options for {@link Browser.pdf}. */
+interface PdfOptions extends NavigateOptions {
+  /** Paper format (`A4`, `Letter`, …) forwarded to Playwright. */
+  format?: string;
+  /** Print background graphics. Default `false`. */
+  printBackground?: boolean;
+  /**
+  * Viewport used while laying out the page before printing. Hard-capped like
+  * {@link ScreenshotOptions.viewport}.
+  */
+  viewport?: {
+    height: number;
+    width: number;
+  };
+}
+interface LunoraBrowserOptions {
+  /**
+  * Opt out of the SSRF guard that, by default, refuses to navigate to a
+  * private / internal / loopback / link-local host (RFC1918, `127.0.0.0/8`,
+  * `169.254.0.0/16` incl. the cloud-metadata address, CGNAT, IPv6 ULA/
+  * link-local, and `localhost` / `*.internal` / `*.local` literals). Leave it
+  * `false` (the default) unless every caller-supplied URL is trusted — e.g.
+  * you deliberately drive the browser at an internal service reachable through
+  * a Cloudflare Tunnel / private-network binding. Setting it `true` re-opens
+  * the SSRF surface, so never combine it with caller-controlled URLs.
+  */
+  allowPrivateTargets?: boolean;
+  /** The Cloudflare Browser Rendering binding (`env.BROWSER`). Required. */
+  binding: BrowserBindingLike;
+  /**
+  * The `@cloudflare/playwright` `launch` function. Injected rather than
+  * imported at module top so the optional peer dep stays out of the bundle
+  * for non-browser apps and tests can pass a double. The generated worker
+  * passes the real function; omitting it makes the helper throw on first use
+  * with a clear "install `@cloudflare/playwright`" error.
+  */
+  launch?: BrowserLaunchLike;
+  /**
+  * Default navigation timeout (ms) applied when a per-call `timeoutMs` is not
+  * given. Clamped to the factory's `MAX_TIMEOUT_MS`. Default 30000.
+  */
+  timeoutMs?: number;
+}
+/**
+* The `ctx.browser` surface — Cloudflare Browser Rendering driven through
+* `@cloudflare/playwright`. **Action-only**: every method performs
+* non-deterministic network I/O (it navigates a real headless browser to a
+* URL), so codegen wires it onto `ActionCtx` exclusively — never `QueryCtx`/
+* `MutationCtx` — exactly like `ctx.ai` / `ctx.fetch`. Each helper launches a
+* browser, opens a context + page, navigates, performs the op, and always
+* closes the browser in a `finally` (a leaked session is billed and
+* rate-limited).
+*/
+interface Browser {
+  /** Serialized HTML of `url` after navigation settles. */
+  content: (url: string, options?: NavigateOptions) => Promise<string>;
+  /**
+  * Low-level escape hatch: launch a raw Playwright `Browser` and hand it to
+  * `fn` (e.g. for multi-page flows or APIs not surfaced here). The browser is
+  * **always closed** when `fn` resolves or throws — do not retain references
+  * to it past the callback.
+  */
+  launch: <T>(function_: (browser: BrowserLike) => Promise<T>) => Promise<T>;
+  /** Render `url` to a PDF buffer. */
+  pdf: (url: string, options?: PdfOptions) => Promise<Uint8Array>;
+  /**
+  * Navigate to `url`, run `fn` inside the page context, and return its
+  * (serializable) result. `fn` runs in the browser, not the worker — it
+  * cannot close over worker-side variables.
+  */
+  scrape: <T>(url: string, function_: (...args: never[]) => T, options?: NavigateOptions) => Promise<T>;
+  /** Render `url` to an image buffer (PNG by default). */
+  screenshot: (url: string, options?: ScreenshotOptions) => Promise<Uint8Array>;
+}
+declare const createBrowser: (options: LunoraBrowserOptions) => Browser;
+export { type Browser, type BrowserBindingLike, type BrowserContextLike, type BrowserLaunchLike, type BrowserLike, type LunoraBrowserOptions, type NavigateOptions, type PageLike, type PdfOptions, type ScreenshotOptions, createBrowser };

package/dist/index.mjs

@@ -0,0 +1 @@
+export { createBrowser } from './packem_shared/createBrowser-6RQ-H1k9.mjs';

package/dist/packem_shared/createBrowser-6RQ-H1k9.mjs

@@ -0,0 +1,185 @@
+const DEFAULT_TIMEOUT_MS = 3e4;
+const MAX_TIMEOUT_MS = 12e4;
+const MAX_VIEWPORT_WIDTH = 3840;
+const MAX_VIEWPORT_HEIGHT = 4320;
+const IPV4_OCTET = /^\d{1,3}$/;
+const IPV6_MAPPED_HEX = /^::ffff:([\da-f]{1,4}):([\da-f]{1,4})$/;
+const IPV6_MAPPED_DOTTED = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/;
+const IPV6_COMPATIBLE_DOTTED = /^::(\d{1,3}(?:\.\d{1,3}){3})$/;
+const IPV6_COMPATIBLE_HEX = /^::([\da-f]{1,4}):([\da-f]{1,4})$/;
+const IPV6_NAT64_HEX = /^64:ff9b::[\da-f]{1,4}:[\da-f]{1,4}$/;
+const IPV6_BRACKETS = /^\[|\]$/g;
+const parseIpv4 = (host) => {
+  const parts = host.split(".");
+  if (parts.length !== 4) {
+    return void 0;
+  }
+  const octets = parts.map((part) => IPV4_OCTET.test(part) ? Number(part) : -1);
+  if (octets.some((octet) => octet < 0 || octet > 255)) {
+    return void 0;
+  }
+  const result = [octets[0], octets[1], octets[2], octets[3]];
+  return result;
+};
+const isPrivateIpv4 = ([a, b]) => a === 0 || // 0.0.0.0/8 "this host"
+a === 10 || // 10.0.0.0/8 private
+a === 127 || // 127.0.0.0/8 loopback
+a === 100 && b >= 64 && b <= 127 || // 100.64.0.0/10 CGNAT
+a === 169 && b === 254 || // 169.254.0.0/16 link-local (incl. 169.254.169.254 metadata)
+a === 172 && b >= 16 && b <= 31 || // 172.16.0.0/12 private
+a === 192 && b === 168 || // 192.168.0.0/16 private
+a >= 224;
+const isPrivateEmbeddedIpv4 = (highGroup, lowGroup) => {
+  const high = Number.parseInt(highGroup ?? "", 16);
+  const low = Number.parseInt(lowGroup ?? "", 16);
+  if (!Number.isFinite(high) || !Number.isFinite(low)) {
+    return true;
+  }
+  return isPrivateIpv4([Math.floor(high / 256), high % 256, Math.floor(low / 256), low % 256]);
+};
+const isPrivateIpv6 = (host) => {
+  const ip = host.toLowerCase();
+  const mappedHex = IPV6_MAPPED_HEX.exec(ip);
+  if (mappedHex) {
+    return isPrivateEmbeddedIpv4(mappedHex[1], mappedHex[2]);
+  }
+  const mappedDotted = IPV6_MAPPED_DOTTED.exec(ip);
+  if (mappedDotted) {
+    const v4 = parseIpv4(mappedDotted[1] ?? "");
+    return v4 === void 0 || isPrivateIpv4(v4);
+  }
+  const compatDotted = IPV6_COMPATIBLE_DOTTED.exec(ip);
+  if (compatDotted) {
+    const v4 = parseIpv4(compatDotted[1] ?? "");
+    return v4 === void 0 || isPrivateIpv4(v4);
+  }
+  const compatHex = IPV6_COMPATIBLE_HEX.exec(ip);
+  if (compatHex) {
+    return isPrivateEmbeddedIpv4(compatHex[1], compatHex[2]);
+  }
+  if (IPV6_NAT64_HEX.test(ip)) {
+    return true;
+  }
+  return ip === "::" || // unspecified
+  ip === "::1" || // loopback
+  ip.startsWith("fc") || // fc00::/7 unique-local
+  ip.startsWith("fd") || // fc00::/7 unique-local
+  ip.startsWith("fe8") || // fe80::/10 link-local
+  ip.startsWith("fe9") || ip.startsWith("fea") || ip.startsWith("feb");
+};
+const isPrivateHostname = (host) => host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal") || host.endsWith(".home.arpa");
+const isPrivateTarget = (parsed) => {
+  const host = parsed.hostname.replaceAll(IPV6_BRACKETS, "");
+  if (host.includes(":")) {
+    return isPrivateIpv6(host);
+  }
+  const v4 = parseIpv4(host);
+  return v4 === void 0 ? isPrivateHostname(host.toLowerCase()) : isPrivateIpv4(v4);
+};
+const validateUrl = (url, allowPrivateTargets) => {
+  if (typeof url !== "string" || url.length === 0) {
+    throw new Error("@lunora/browser: url must be a non-empty string");
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`@lunora/browser: url must be an absolute http(s) URL (got "${url}")`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`@lunora/browser: url protocol must be http(s) (got "${parsed.protocol}")`);
+  }
+  if (parsed.username !== "" || parsed.password !== "") {
+    throw new Error("@lunora/browser: url must not embed credentials (strip the `user:pass@` userinfo)");
+  }
+  if (!allowPrivateTargets && isPrivateTarget(parsed)) {
+    throw new Error(
+      `@lunora/browser: url host "${parsed.hostname}" is a private/internal address; pass createBrowser({ …, allowPrivateTargets: true }) to allow it`
+    );
+  }
+  return parsed.toString();
+};
+const clampDimension = (value, max) => {
+  if (!Number.isFinite(value)) {
+    return max;
+  }
+  return Math.min(Math.max(1, Math.floor(value)), max);
+};
+const clampViewport = (viewport) => {
+  return {
+    height: clampDimension(viewport.height, MAX_VIEWPORT_HEIGHT),
+    width: clampDimension(viewport.width, MAX_VIEWPORT_WIDTH)
+  };
+};
+const resolveTimeout = (callTimeout, factoryTimeout) => {
+  const requested = callTimeout ?? factoryTimeout ?? DEFAULT_TIMEOUT_MS;
+  const safe = Number.isFinite(requested) ? requested : DEFAULT_TIMEOUT_MS;
+  return Math.min(Math.max(1, Math.floor(safe)), MAX_TIMEOUT_MS);
+};
+const createBrowser = (options) => {
+  if (!options.binding) {
+    throw new Error("@lunora/browser: `binding` is required (env.BROWSER)");
+  }
+  const getLaunch = () => {
+    if (!options.launch) {
+      throw new Error(
+        '@lunora/browser: `launch` is not available — install the `@cloudflare/playwright` peer dependency. The generated worker wires it for you; outside codegen pass it via createBrowser({ binding, launch }) (import { launch } from "@cloudflare/playwright").'
+      );
+    }
+    return options.launch;
+  };
+  const withBrowser = async (use) => {
+    const browser = await getLaunch()(options.binding);
+    try {
+      return await use(browser);
+    } finally {
+      try {
+        await browser.close();
+      } catch {
+      }
+    }
+  };
+  const withPage = async (url, navigate, use, viewport) => {
+    const target = validateUrl(url, options.allowPrivateTargets ?? false);
+    const timeout = resolveTimeout(navigate.timeoutMs, options.timeoutMs);
+    return withBrowser(async (browser) => {
+      const context = await browser.newContext();
+      const page = await context.newPage();
+      if (viewport && page.setViewportSize) {
+        await page.setViewportSize(clampViewport(viewport));
+      }
+      await page.goto(target, { timeout, waitUntil: navigate.waitUntil ?? "load" });
+      return use(page);
+    });
+  };
+  const screenshot = async (url, screenshotOptions = {}) => withPage(
+    url,
+    screenshotOptions,
+    async (page) => page.screenshot({
+      fullPage: screenshotOptions.fullPage ?? false,
+      type: screenshotOptions.type ?? "png"
+    }),
+    screenshotOptions.viewport
+  );
+  const pdf = async (url, pdfOptions = {}) => withPage(
+    url,
+    pdfOptions,
+    async (page) => page.pdf({
+      format: pdfOptions.format,
+      printBackground: pdfOptions.printBackground ?? false
+    }),
+    pdfOptions.viewport
+  );
+  const content = async (url, navigateOptions = {}) => withPage(url, navigateOptions, async (page) => page.content());
+  const scrape = async (url, function_, navigateOptions = {}) => withPage(url, navigateOptions, async (page) => page.evaluate(function_));
+  const launch = async (function_) => withBrowser(function_);
+  return {
+    content,
+    launch,
+    pdf,
+    scrape,
+    screenshot
+  };
+};
+
+export { createBrowser };

package/package.json

@@ -1,31 +1,59 @@
 {
   "name": "@lunora/browser",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.1",
   "description": "Cloudflare Browser Rendering for Lunora: ctx.browser screenshots, PDF, and scraping in actions",
-  "license": "FSL-1.1-Apache-2.0",
+  "keywords": [
+    "browser-rendering",
+    "cloudflare",
+    "lunora",
+    "pdf",
+    "playwright",
+    "scrape",
+    "screenshot",
+    "workers"
+  ],
   "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anolilab/lunora.git",
     "directory": "packages/browser"
   },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
-  "keywords": [
-    "lunora",
-    "cloudflare",
-    "workers",
-    "browser-rendering",
-    "playwright",
-    "screenshot",
-    "pdf",
-    "scrape"
+  "files": [
+    "dist",
+    "__assets__",
+    "README.md",
+    "LICENSE.md"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "peerDependencies": {
+    "@cloudflare/playwright": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@cloudflare/playwright": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }