@pagesift/node 0.0.0-stage → 0.40.0

package/README.md

@@ -1,3 +1,177 @@
-# Temporary Holding Version
+# pagesift (Node.js)
 
-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.
+0.20.0: see the [release and migration guide](https://github.com/YOLOW92/pagesift/blob/main/docs/releases/0.20.0.md). New collection/archive cores are available through Rust and CLI; this package keeps its documented scraping interface.
+
+The npm package `pagesift`: pagesift's Rust engine for Node.js, built with [napi-rs](https://napi.rs).
+Prebuilt binaries, so you don't need a Rust toolchain or a headless-browser download.
+The API is designed for throughput first: batches are scheduled in Rust, results stay in Rust until you read them,
+and CPU work never runs on the Node main thread unless you ask for the synchronous `convert`.
+
+```js
+import { readFile } from 'node:fs/promises'
+import { convert, convertMany, Scraper, PagesiftError } from 'pagesift'
+
+// HTML you already have -> Markdown (no network)
+const page = convert(html, { url: 'https://example.com/post' })
+console.log(page.markdown, page.metadata.title)
+
+// Many documents: one call, bounded Rust workers, bytes in (no string transcoding)
+const pages = await convertMany(await Promise.all(files.map((f) => readFile(f))))
+
+// Fetching: create one Scraper and keep it (connection pool, robots.txt cache, rate-limit state, browsers)
+const scraper = new Scraper()
+try {
+  const p = await scraper.scrape('https://example.com', { formats: ['markdown', 'links'] })
+} catch (e) {
+  if (e instanceof PagesiftError) console.log(e.code, e.details) // e.g. ROBOTS_DISALLOWED
+}
+
+// Results as they finish; `break` cancels the rest
+for await (const { url, page, error } of scraper.scrapeStream(urls, { concurrency: 32 })) {
+  if (error) console.log(url, error.code)
+  else console.log(url, page.markdown.length)
+}
+await scraper.close()
+```
+
+## API
+
+| | Returns | Notes |
+|---|---|---|
+| `convert(html, options?)` | `Page` | Synchronous, on the calling thread |
+| `convertAsync(html, options?)` | `Promise<Page>` | On a Rust thread |
+| `convertMany(htmls, options?)` | `Promise<Page[]>` | Whole batch in parallel in Rust; same order as input |
+| `new Scraper(config?)` | | Keep one instance for the life of the process |
+| `scraper.scrape(url, options?)` | `Promise<Page>` | Rejects with `PagesiftError` |
+| `scraper.scrapeMany(urls, options?)` | `Promise<BatchItem[]>` | Same order as input; one failure only affects its own item |
+| `scraper.scrapeStream(urls, options?)` | async iterable of `BatchItem` | Completion order; leaving the loop cancels pending work |
+| `scraper.close()` | `Promise<void>` | Stops browser processes |
+
+`html` is a `string` or UTF-8 bytes (`Uint8Array` / `Buffer`). Don't modify a buffer while a call that uses it is running.
+
+**Options.** `formats` (`'markdown' | 'html' | 'rawHtml' | 'links' | 'images'`, default `['markdown']`; only the listed outputs are computed),
+`onlyMainContent` (default `true`), `url` (convert only). Scraping adds `engine` (`auto` / `http` / `browser`), `timeout`, `waitFor`,
+`headers`, `ignoreRobotsTxt`, `mobile`, `blockAds`, `ifNoneMatch`, `ifModifiedSince`; batches add `concurrency` (default 16).
+
+**`Page`.** `markdown`, `html`, `rawHtml`, `links`, `images` (`null` when not requested) and `metadata`
+(title, description, language, `statusCode`, `og*` keys, and `metadata.pagesift`: content hashes, redirect chain, ETag, engine used, timings).
+Each property read copies that one field into JS; fields you never read are never copied. `toJSON()` returns everything as a plain object.
+
+**`BatchItem`.** `{ index, url, page?, error? }`, with exactly one of `page` or `error`.
+`error` is `{ code, message, details?, retryAfter? }`, a plain object rather than an `Error`, so a big batch doesn't collect stack traces.
+
+**Errors.** Single calls throw or reject with `PagesiftError` (`code`, `details`, `retryAfter`). The codes match the pagesift HTTP API:
+`ROBOTS_DISALLOWED`, `ACCESS_BARRIER`, `RATE_LIMITED`, `HOST_COOLDOWN`, `TIMEOUT`, `SSRF_BLOCKED`, `TOO_LARGE`,
+`UPSTREAM_ERROR`, `NETWORK_ERROR`, `DNS_FAILURE`, `BUSY`, `UNSUPPORTED_OPTION`, `INVALID_REQUEST`, `INTERNAL_ERROR`.
+pagesift never tries to get around a block: an access barrier is reported with `details` (vendor, kind, confidence), not bypassed.
+
+**`Scraper` config.** `userAgent`, `allowPrivateNetwork` (off by default), `requestIntervalMs` (per host, default 1000),
+`perHostConcurrency` (default 2), `maxBrowsers`.
+
+## Why it's shaped this way: benchmarks
+
+Measured on 2026-10-21 on linux-x64 with 16 threads, Node v24.21.0, release build. Other jobs were running on the machine
+(load average 2–6), so take the absolute numbers as rough; the ratios are what matter.
+Reproduce with `bench/bench.mjs` (see Development).
+
+### Against Readability + Turndown
+
+Same 597 pages (the frozen pagesift evaluation set, 179 MB of HTML). Readability needs a DOM, so JSDOM parsing is included in its time.
+
+| Metric | pagesift | Readability + Turndown | |
+|---|---|---|---|
+| Per-page time p50, ms (lower is better) | 2.34 | 121.80 | 52× faster |
+| Per-page time p95, ms (lower is better) | 11.86 | 716.18 | 60× faster |
+| Per-page time mean, ms (lower is better) | 4.20 | 252.15 | 60× faster |
+| Throughput, pages/s (higher is better; pagesift `convertMany` with Buffer input, Readability is single-threaded) | 1284 | 4.0 | 324× |
+| Peak process RSS, MB (lower is better) | 1248 | 4455 | 72% lower |
+
+### Batching and zero-copy input (same 597 pages)
+
+| Approach | Throughput, pages/s (higher is better) | vs sync | Main-thread utilisation (lower is better) |
+|---|---|---|---|
+| `convert` in a loop | 238 | 1× | 100% |
+| `convertAsync` × 597 + `Promise.all` | 857 | 3.6× | 55% |
+| `convertMany` with strings | 874 | 3.7× | 65% |
+| `convertMany` with Buffers | **1284** | **5.4×** | **17%** |
+| `convertMany` with Buffers, all four formats (for comparison) | 800 | 3.4× | — |
+
+Turning a JS string into Rust UTF-8 has to happen on the main thread, and for 179 MB that's most of the remaining main-thread work.
+With bytes there's nothing to transcode. `convertMany` with strings runs that whole transcoding inside one call, so for very large
+string batches either pass Buffers or split the batch.
+Computing only the formats you ask for adds another 1.6× (1284 vs 800 pages/s).
+
+### Lazy fields (one batch of 597 `Page`s with markdown, html, links and images computed)
+
+| Read | Main-thread time, ms (lower is better) |
+|---|---|
+| `page.markdown` only | 13.81 |
+| `page.toJSON()` (everything) | 203.17 |
+
+Fields stay in Rust until read, so reading only what you need is 15× cheaper on the main thread.
+
+### Scraping (local HTTP server in a child process, 16 hosts, ~3 KB pages, so fixed per-request costs dominate)
+
+| Design | Measurement | Result |
+|---|---|---|
+| Reuse one `Scraper` | 100 sequential pages, one Scraper, ms (lower is better) | 34 |
+| | 100 sequential pages, new Scraper per page, ms (lower is better) | 289 (8.6× slower) |
+| Batches scheduled in Rust | `scrapeMany`, 2000 pages, pages/s (higher is better) | 13864 |
+| | `scrape` × 2000 + `Promise.all`, pages/s (higher is better) | 14329 |
+| | Main-thread utilisation during `scrapeMany` (lower is better) | **2%** |
+| | Main-thread utilisation during `scrape` + `Promise.all` (lower is better) | 51% |
+| Completion order | `scrapeMany`: first result, one 1 s page among 99 fast ones, ms (lower is better) | 1002 |
+| | `scrapeStream`: first result, ms (lower is better) | **21** |
+| | `scrapeStream`: all 99 fast pages, ms (lower is better) | 157 |
+
+A new `Scraper` per page pays for a fresh connection and a robots.txt fetch every time.
+`scrapeMany` and individual `scrape` calls reach the same throughput, but the batch leaves the main thread almost idle (2% vs 51%),
+which matters when the same process also serves requests. `scrapeStream` delivers results as soon as each page finishes instead of waiting for the slowest one.
+
+Known limit: requests to a single host currently top out at about 1000 per second even with `requestIntervalMs: 0`
+(the rate limiter waits for a 1 ms timer tick per request), which is why this benchmark spreads its pages over 16 hosts.
+
+## CPU budget
+
+Asynchronous conversion shares at most `max(1, logical CPUs - 1)` Rust worker slots across calls,
+leaving capacity for Node's event loop. `convertMany` validates and copies all inputs before starting
+CPU workers, so parser work does not compete with the main thread while it copies strings.
+Large string batches still copy synchronously; use UTF-8 buffers or smaller batches when needed.
+The timing figures above predate this 0.20.0 scheduling change; rerun them on your deployment hardware.
+
+## Platforms
+
+| Target | Status |
+|---|---|
+| linux-x64-gnu, linux-arm64-gnu | native build and full binding tests in Linux CI |
+| darwin-x64, darwin-arm64 | native build and full binding tests in macOS CI |
+| linux-x64-musl | native musl build and full binding tests on Alpine |
+| win32-x64-msvc | native MSVC build and full binding tests on Windows |
+
+Node 18 or newer is required. `npm install pagesift` selects the matching optional native package;
+Linux musl and glibc packages are separate. Windows supports conversion and HTTP scraping;
+local browser process management is unavailable. The Rust CDP client can connect to an existing remote endpoint.
+
+## Development
+
+```bash
+npm install
+npm run build        # release build + index.js / index.d.ts
+npm test             # node --test, local HTTP server only
+```
+
+Benchmarks, from the repository root:
+
+```bash
+node crates/pagesift-node/bench/bench.mjs extract bench/data/inputs/manifest.jsonl <dir with jsdom, @mozilla/readability, turndown in node_modules>
+node crates/pagesift-node/bench/bench.mjs scrape
+```
+
+`index.js` and `index.d.ts` are generated by `napi build` (types from `src/`, plus `header.d.ts`) and committed.
+`scripts/postbuild.mjs` adds the two exports the generated loader can't see (`PagesiftError`, `version`).
+
+This crate doesn't use `#![forbid(unsafe_code)]`, because the napi-rs macros generate unsafe code. Our own code here contains no `unsafe`.
+
+## License
+
+AGPL-3.0-only, with a commercial license available for use without AGPL obligations. See the repository's [LICENSE](../../LICENSE) and [COMMERCIAL.md](../../COMMERCIAL.md).

package/index.d.ts

@@ -0,0 +1,258 @@
+/* eslint-disable */
+/* 由 napi-rs 根据 src/ 生成；本段手写的类型来自 header.d.ts。 */
+
+/** 包版本。 */
+export declare const version: string
+
+/** 和 pagesift HTTP 接口一致的错误码。 */
+export type ErrorCode =
+  | 'ROBOTS_DISALLOWED'
+  | 'ACCESS_BARRIER'
+  | 'RATE_LIMITED'
+  | 'HOST_COOLDOWN'
+  | 'TIMEOUT'
+  | 'SSRF_BLOCKED'
+  | 'TOO_LARGE'
+  | 'UPSTREAM_ERROR'
+  | 'NETWORK_ERROR'
+  | 'DNS_FAILURE'
+  | 'BUSY'
+  | 'UNSUPPORTED_OPTION'
+  | 'INVALID_REQUEST'
+  | 'INTERNAL_ERROR'
+
+/** 抓取或转换失败时抛出（或 Promise 以它拒绝）。 */
+export declare class PagesiftError extends Error {
+  readonly name: 'PagesiftError'
+  readonly code: ErrorCode
+  /** 补充信息，比如拦截页的 `{ vendor, kind, confidence, ruleId }`。 */
+  readonly details?: unknown
+  /** 限流时建议多少秒后再试。 */
+  readonly retryAfter?: number
+}
+
+export type Format = 'markdown' | 'html' | 'rawHtml' | 'links' | 'images'
+
+/** `Page.toJSON()` 的结果：一次取出全部字段的普通对象，没请求的格式不出现。 */
+export interface PageJSON {
+  markdown?: string
+  html?: string
+  rawHtml?: string
+  links?: string[]
+  images?: string[]
+  metadata: PageMetadata
+}
+
+export interface PageMetadata {
+  title?: string
+  description?: string
+  language?: string
+  keywords?: string
+  robots?: string
+  favicon?: string
+  publishedTime?: string
+  modifiedTime?: string
+  /** 最终地址（跟随重定向之后）。 */
+  url?: string
+  /** 请求的地址。 */
+  sourceURL?: string
+  /** 只有抓取结果才有。 */
+  statusCode?: number
+  contentType?: string
+  proxyUsed?: string
+  /** PDF 的页数。 */
+  numPages?: number
+  /** 抓取结果的 pagesift 扩展字段。 */
+  pagesift?: PagesiftMetadata
+  /** `ogImage`、`twitterCard`、`articlePublishedTime` 这类 meta，键名是 camelCase。 */
+  [key: string]: unknown
+}
+
+export interface PagesiftMetadata {
+  /** Markdown、原始 HTML、正文纯文本的 BLAKE3 哈希（十六进制）。 */
+  contentHash?: string
+  /** Computed only when change tracking is enabled in a supporting API surface. */
+  rawHash?: string
+  textHash?: string
+  redirectChain?: string[]
+  etag?: string
+  lastModified?: string
+  /** 条件请求命中，页面没变（此时没有 markdown）。 */
+  notModified?: boolean
+  /** 这一页实际用的抓取方式。 */
+  engine?: 'http' | 'browser'
+  warnings?: string[]
+  /** 各阶段耗时，毫秒。 */
+  timings?: Record<string, number>
+}
+
+
+/**
+ * Which binding artifact the generated loader actually loaded: `'native'` for
+ * a native addon, otherwise the `platformArchABI` of the WASI flavor. Every
+ * flavor napi-rs can build is listed, because `NAPI_RS_NATIVE_LIBRARY_PATH`
+ * can point the loader at a WASI artifact this package does not build itself.
+ */
+export declare const __napiBindingTarget: 'native' | 'wasm32-wasi' | 'wasm32-wasip1'
+
+declare global {
+  interface __NapiRsAsyncGenerator<TOwner, T, TReturn, TNext> {
+    next(...[value]: [] | [TNext]): globalThis.Promise<globalThis.IteratorResult<T, TReturn | undefined>>
+    return(...[value]: [] | [TReturn]): globalThis.Promise<globalThis.IteratorResult<T, TReturn | undefined>>
+    throw(exception?: unknown): globalThis.Promise<globalThis.IteratorResult<T, TReturn | undefined>>
+    [globalThis.Symbol.asyncIterator](): this
+  }
+}
+
+/** 一页的转换或抓取结果。每次读属性都会新建一个 JS 值，需要多次使用时先存到变量里。 */
+export declare class Page {
+  /** 正文的 Markdown；`formats` 里没有 `markdown`、或条件请求命中（`notModified`）时为 null。 */
+  get markdown(): string | null
+  /** 清洗后的 HTML（`formats` 含 `html` 时才有）。 */
+  get html(): string | null
+  /** 原始 HTML（`formats` 含 `rawHtml` 时才有）。 */
+  get rawHtml(): string | null
+  /** 页面里的链接，绝对地址（`formats` 含 `links` 时才有）。 */
+  get links(): Array<string> | null
+  /** 页面里的图片地址（`formats` 含 `images` 时才有）。 */
+  get images(): Array<string> | null
+  /** 标题、描述、状态码、`og:*` 等元数据，以及 `pagesift` 扩展字段。 */
+  get metadata(): PageMetadata
+  /** 一次性取出全部字段，得到普通对象（`JSON.stringify(page)` 也会调用它）。 */
+  toJSON(): PageJSON
+}
+
+/** 抓取器：连接池、robots.txt 缓存、限速状态和浏览器池都在它里面，长期复用一个实例最快。 */
+export declare class Scraper {
+  constructor(config?: ScraperConfig | undefined | null)
+  /** 抓取一个 URL。失败时 Promise 以 `PagesiftError` 拒绝。 */
+  scrape(url: string, options?: ScrapeOptions | undefined | null): Promise<Page>
+  /** 抓取一批 URL，全部完成后一次返回，顺序和输入一致；单个失败只影响它自己的那一项。 */
+  scrapeMany(urls: Array<string>, options?: BatchOptions | undefined | null): Promise<BatchItem[]>
+  /** 抓取一批 URL，按完成顺序逐个产出（`for await`）。提前 `break` 会取消还没完成的抓取。 */
+  scrapeStream(urls: Array<string>, options?: BatchOptions | undefined | null): ScrapeStream
+  /** 关闭浏览器进程。之后再调用抓取方法会报错。 */
+  close(): Promise<void>
+}
+
+/**
+ * 按完成顺序产出 `BatchItem` 的异步迭代器。
+ *
+ * This type implements JavaScript's async iterable protocol.
+ * It can be used with `for await...of` loops.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_async_iterator_and_async_iterable_protocols
+ */
+export declare class ScrapeStream {
+
+  [globalThis.Symbol.asyncIterator](): globalThis.__NapiRsAsyncGenerator<ScrapeStream, BatchItem, void, undefined>
+}
+
+/** 批量结果里单个 URL 的错误：字段和 `PagesiftError` 一致，但不是 Error 实例（不采集调用栈）。 */
+export interface BatchError {
+  code: ErrorCode
+  message: string
+  details?: unknown
+  /** 限流时建议多少秒后再试。 */
+  retryAfter?: number
+}
+
+/** 批量抓取里一个 URL 的结果：`page` 和 `error` 恰好有一个。 */
+export interface BatchItem {
+  /** 在输入数组里的下标。 */
+  index: number
+  url: string
+  page?: Page
+  error?: BatchError
+}
+
+/** 批量抓取选项：`ScrapeOptions` 的全部字段，加上并发数。 */
+export interface BatchOptions {
+  /** 同时进行的抓取数，默认 16；同一主机仍受限速约束。 */
+  concurrency?: number
+  /** 计算哪些输出，默认 `['markdown']`；只算需要的，越少越快。 */
+  formats?: Format[]
+  /** 只保留正文，去掉导航、页眉页脚、侧边栏，默认 true。 */
+  onlyMainContent?: boolean
+  /** `auto`（默认，正文太少时改用浏览器渲染）、`http` 或 `browser`。 */
+  engine?: 'auto' | 'http' | 'browser'
+  /** 总超时，毫秒，至少 1000。 */
+  timeout?: number
+  /** 浏览器渲染时页面加载后再等待多久，毫秒。 */
+  waitFor?: number
+  /** 额外的请求头。 */
+  headers?: Record<string, string>
+  /** 这一页不检查 robots.txt（只对单页抓取有效）。 */
+  ignoreRobotsTxt?: boolean
+  /** 浏览器渲染时模拟手机。 */
+  mobile?: boolean
+  /** 浏览器渲染时屏蔽广告，默认 true。 */
+  blockAds?: boolean
+  /** 条件请求：`If-None-Match`。 */
+  ifNoneMatch?: string
+  /** 条件请求：`If-Modified-Since`（HTTP 日期）。 */
+  ifModifiedSince?: string
+}
+
+/** 把一段 HTML 转成 Markdown，在当前线程上同步执行（会阻塞事件循环，适合脚本和小页面）。 */
+export declare function convert(html: string | Uint8Array, options?: ConvertOptions): Page
+
+/** 和 `convert` 相同，但在后台线程上执行，不阻塞事件循环。 */
+export declare function convertAsync(html: string | Uint8Array, options?: ConvertOptions): Promise<Page>
+
+/**
+ * 批量转换：使用共享的 Rust CPU 名额，结果顺序和输入一致。
+ * 先完成主线程上的输入校验和字符串复制，再启动 CPU 工作，避免输入复制与解析争用 CPU。
+ * `Uint8Array` 省去 UTF-8 字符串复制；调用完成前不得修改它。
+ */
+export declare function convertMany(htmls: Array<string | Uint8Array>, options?: ConvertOptions): Promise<Page[]>
+
+/** `convert`、`convertAsync`、`convertMany` 的选项。 */
+export interface ConvertOptions {
+  /** 页面地址：把相对链接转成绝对地址，也写进 `metadata.url`。 */
+  url?: string
+  /** 只保留正文（去掉导航、页眉页脚、侧边栏等），默认 true。 */
+  onlyMainContent?: boolean
+  /** 计算哪些输出，默认 `['markdown']`；只算需要的，越少越快。 */
+  formats?: Format[]
+}
+
+/** 单页抓取选项。 */
+export interface ScrapeOptions {
+  /** 计算哪些输出，默认 `['markdown']`；只算需要的，越少越快。 */
+  formats?: Format[]
+  /** 只保留正文，去掉导航、页眉页脚、侧边栏，默认 true。 */
+  onlyMainContent?: boolean
+  /** `auto`（默认，正文太少时改用浏览器渲染）、`http` 或 `browser`。 */
+  engine?: 'auto' | 'http' | 'browser'
+  /** 总超时，毫秒，至少 1000。 */
+  timeout?: number
+  /** 浏览器渲染时页面加载后再等待多久，毫秒。 */
+  waitFor?: number
+  /** 额外的请求头。 */
+  headers?: Record<string, string>
+  /** 这一页不检查 robots.txt（只对单页抓取有效）。 */
+  ignoreRobotsTxt?: boolean
+  /** 浏览器渲染时模拟手机。 */
+  mobile?: boolean
+  /** 浏览器渲染时屏蔽广告，默认 true。 */
+  blockAds?: boolean
+  /** 条件请求：`If-None-Match`。 */
+  ifNoneMatch?: string
+  /** 条件请求：`If-Modified-Since`（HTTP 日期）。 */
+  ifModifiedSince?: string
+}
+
+/** `Scraper` 的构造参数。 */
+export interface ScraperConfig {
+  /** 请求头里的 User-Agent。 */
+  userAgent?: string
+  /** 允许抓取内网、回环地址（默认拒绝，防 SSRF；只作用于 HTTP 抓取）。 */
+  allowPrivateNetwork?: boolean
+  /** 同一主机两次请求之间的最小间隔，毫秒，默认 1000；robots.txt 的 Crawl-delay 优先。 */
+  requestIntervalMs?: number
+  /** 同一主机同时进行的请求数，默认 2。 */
+  perHostConcurrency?: number
+  /** 浏览器渲染时最多启动的浏览器进程数。 */
+  maxBrowsers?: number
+}

package/index.js

@@ -0,0 +1,788 @@
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require('fs')
+let nativeBinding = null
+// Which artifact actually loaded. The WASI fallback chain overwrites it with
+// the flavor it resolved; the late native retry below leaves it alone because
+// it only runs while no WASI candidate has been loaded.
+let __napiLoadedBindingTarget = 'native'
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (process.report && typeof process.report.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      const overrideBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH)
+      // The override may be a generated WASI loader, which already reports its
+      // own flavor. Adopt it: `module.exports` aliases this object, so claiming
+      // 'native' would both misreport the artifact and overwrite the loader's
+      // marker through the alias.
+      __napiLoadedBindingTarget =
+        overrideBinding && typeof overrideBinding.__napiBindingTarget === 'string'
+          ? overrideBinding.__napiBindingTarget
+          : 'native'
+      return overrideBinding
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./pagesift.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-android-arm64')
+        const bindingPackageVersion = require('@pagesift/node-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./pagesift.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-android-arm-eabi')
+        const bindingPackageVersion = require('@pagesift/node-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      if ((process.config && process.config.variables && process.config.variables.shlib_suffix === 'dll.a') || (process.config && process.config.variables && process.config.variables.node_target_type === 'shared_library')) {
+        try {
+          return require('./pagesift.win32-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-win32-x64-gnu')
+          const bindingPackageVersion = require('@pagesift/node-win32-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./pagesift.win32-x64-msvc.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-win32-x64-msvc')
+          const bindingPackageVersion = require('@pagesift/node-win32-x64-msvc/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./pagesift.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-win32-ia32-msvc')
+        const bindingPackageVersion = require('@pagesift/node-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./pagesift.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-win32-arm64-msvc')
+        const bindingPackageVersion = require('@pagesift/node-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./pagesift.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('@pagesift/node-darwin-universal')
+      const bindingPackageVersion = require('@pagesift/node-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./pagesift.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-darwin-x64')
+        const bindingPackageVersion = require('@pagesift/node-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./pagesift.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-darwin-arm64')
+        const bindingPackageVersion = require('@pagesift/node-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./pagesift.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-freebsd-x64')
+        const bindingPackageVersion = require('@pagesift/node-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./pagesift.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-freebsd-arm64')
+        const bindingPackageVersion = require('@pagesift/node-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./pagesift.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-linux-x64-musl')
+          const bindingPackageVersion = require('@pagesift/node-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./pagesift.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-linux-x64-gnu')
+          const bindingPackageVersion = require('@pagesift/node-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./pagesift.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-linux-arm64-musl')
+          const bindingPackageVersion = require('@pagesift/node-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./pagesift.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-linux-arm64-gnu')
+          const bindingPackageVersion = require('@pagesift/node-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./pagesift.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-linux-arm-musleabihf')
+          const bindingPackageVersion = require('@pagesift/node-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./pagesift.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('@pagesift/node-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'loong64') {
+      if (isMusl()) {
+        try {
+          return require('./pagesift.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-linux-loong64-musl')
+          const bindingPackageVersion = require('@pagesift/node-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./pagesift.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-linux-loong64-gnu')
+          const bindingPackageVersion = require('@pagesift/node-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./pagesift.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-linux-riscv64-musl')
+          const bindingPackageVersion = require('@pagesift/node-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./pagesift.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@pagesift/node-linux-riscv64-gnu')
+          const bindingPackageVersion = require('@pagesift/node-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./pagesift.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-linux-ppc64-gnu')
+        const bindingPackageVersion = require('@pagesift/node-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./pagesift.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-linux-s390x-gnu')
+        const bindingPackageVersion = require('@pagesift/node-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./pagesift.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-openharmony-arm64')
+        const bindingPackageVersion = require('@pagesift/node-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./pagesift.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-openharmony-x64')
+        const bindingPackageVersion = require('@pagesift/node-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./pagesift.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@pagesift/node-openharmony-arm')
+        const bindingPackageVersion = require('@pagesift/node-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.40.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+function createLoadErrorChain(errors) {
+  return errors.reduce((previous, current) => {
+    let message
+    try {
+      message =
+        current && typeof current.message === 'string'
+          ? current.message
+          : String(current)
+    } catch {
+      message = 'Unknown error'
+    }
+    const error = new Error(message)
+    error.cause = previous
+    return error
+  }, null)
+}
+
+// NAPI_RS_FORCE_WASI is a tri-state flag:
+//   unset / any other value → native binding preferred, WASI is only a fallback
+//   'true'                   → prefer WASI, but retain native as a lazy fallback
+//   'error'                  → require WASI without initializing a native fallback
+// Treating any non-empty string as truthy (the historical behavior) meant
+// NAPI_RS_FORCE_WASI=false, NAPI_RS_FORCE_WASI=0, etc. inadvertently triggered
+// the WASI path, causing ENOENT for packages shipped without a .wasi.cjs file.
+//
+// NAPI_RS_WASI_FLAVOR selects one exact generated flavor and implies strict
+// WASI loading. It never crosses into another flavor or falls back to native.
+const __napiWasiFlavors = ['wasm32-wasi']
+const __napiWasiFlavor = process.env.NAPI_RS_WASI_FLAVOR
+const __napiWasiFlavorRequested =
+  typeof __napiWasiFlavor === 'string' && __napiWasiFlavor.length > 0
+if (
+  __napiWasiFlavorRequested &&
+  __napiWasiFlavors.indexOf(__napiWasiFlavor) === -1
+) {
+  throw new Error(
+    'Unsupported WASI flavor "' +
+      __napiWasiFlavor +
+      '". Available flavors: ' +
+      __napiWasiFlavors.join(', '),
+  )
+}
+const forceWasiError = process.env.NAPI_RS_FORCE_WASI === 'error'
+const forceWasi =
+  process.env.NAPI_RS_FORCE_WASI === 'true' ||
+  forceWasiError ||
+  __napiWasiFlavorRequested
+
+if (!forceWasi) {
+  nativeBinding = requireNative()
+}
+
+if (!nativeBinding || forceWasi) {
+  let wasiBinding = null
+  let wasiBindingLoaded = false
+  const wasiBindingErrors = []
+  const __napiWasiResolveCandidate = (specifier, isPackage, localArtifacts) => {
+    try {
+      require.resolve(specifier)
+    } catch (resolveError) {
+      if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+        throw resolveError
+      }
+      if (isPackage) {
+        try {
+          require.resolve(specifier + '/package.json')
+        } catch (packageError) {
+          if (packageError && packageError.code === 'MODULE_NOT_FOUND') {
+            return resolveError
+          }
+          // An exports restriction proves the package exists even when its
+          // package.json is not public. Preserve the root resolution failure.
+          throw resolveError
+        }
+        // The package exists but its main/export target is broken.
+        throw resolveError
+      }
+      return resolveError
+    }
+    if (localArtifacts) {
+      let artifactError = null
+      for (let i = 0; i < localArtifacts.length; i++) {
+        try {
+          require.resolve(localArtifacts[i])
+          return null
+        } catch (resolveError) {
+          if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+            throw resolveError
+          }
+          artifactError = resolveError
+        }
+      }
+      return artifactError
+    }
+    return null
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === 'wasm32-wasi')) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('./pagesift.wasi.cjs', false, ['./pagesift.wasm32-wasi.debug.wasm', './pagesift.wasm32-wasi.wasm'])
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        wasiBinding = require('./pagesift.wasi.cjs')
+        nativeBinding = wasiBinding
+        __napiLoadedBindingTarget = 'wasm32-wasi'
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === 'wasm32-wasi')) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('pagesift-wasm32-wasi', true, undefined)
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        if (process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          const bindingPackageVersion = require('@pagesift/node-wasm32-wasi/package.json').version
+          if (bindingPackageVersion !== '0.40.0') {
+            throw new Error(`WASI binding package version mismatch, expected 0.40.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+        }
+        wasiBinding = require('@pagesift/node-wasm32-wasi')
+        nativeBinding = wasiBinding
+        __napiLoadedBindingTarget = 'wasm32-wasi'
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (
+    !wasiBindingLoaded &&
+    forceWasi &&
+    !forceWasiError &&
+    !__napiWasiFlavorRequested
+  ) {
+    nativeBinding = requireNative()
+  }
+  if ((forceWasiError || __napiWasiFlavorRequested) && !wasiBindingLoaded) {
+    const error = new Error(
+      __napiWasiFlavorRequested
+        ? 'WASI binding for flavor "' + __napiWasiFlavor + '" not found'
+        : 'WASI binding not found and NAPI_RS_FORCE_WASI is set to error',
+    )
+    error.cause = createLoadErrorChain(wasiBindingErrors)
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    const error = new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+    )
+    // assign instead of the `new Error(message, { cause })` options form,
+    // which Node < 16.9 silently ignores
+    error.cause = createLoadErrorChain(loadErrors)
+    throw error
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+function __napiStampBindingTarget(exportsObject, target) {
+  if (
+    Object.prototype.hasOwnProperty.call(exportsObject, '__napiBindingTarget')
+  ) {
+    if (exportsObject.__napiBindingTarget === target) {
+      // Already ours: the root entry aliases the object it loaded, so a WASI
+      // fallback candidate — or a `NAPI_RS_NATIVE_LIBRARY_PATH` override that
+      // is a generated loader — arrives already stamped with this same value.
+      return target
+    }
+    const error = new Error(
+      '`__napiBindingTarget` is reserved by the generated binding loader, but the loaded binding already exports it. Rename the export, e.g. #[napi(js_name = "...")].',
+    )
+    error.code = 'ERR_NAPI_BINDING_TARGET_CONFLICT'
+    throw error
+  }
+  if (!Object.isExtensible(exportsObject)) {
+    // A `#[napi(module_exports)]` hook may seal or freeze this object
+    // (`Object::seal` / `Object::freeze`). Reporting the artifact is metadata,
+    // never a reason to fail an otherwise successful load, so the stamp is
+    // skipped. What a consumer still sees then follows the entry point: the
+    // browser and deferred loaders declare `__napiBindingTarget` at module
+    // level and go on reporting it, while the CommonJS entries hand back this
+    // very object as `module.exports`, so there the value is absent.
+    return target
+  }
+  try {
+    // [[Define]], not [[Set]]: an ordinary assignment walks the prototype
+    // chain, so an inherited accessor could swallow the value or throw and
+    // fail an otherwise successful load. The descriptor is what a successful
+    // assignment would have produced.
+    Object.defineProperty(exportsObject, '__napiBindingTarget', {
+      configurable: true,
+      enumerable: true,
+      value: target,
+      writable: true,
+    })
+  } catch {
+    // Same rule as the non-extensible skip above: reporting the artifact is
+    // metadata, never a reason to fail an otherwise successful load. An exotic
+    // object (a Proxy whose defineProperty trap refuses) is skipped, not
+    // thrown over.
+  }
+  // The CommonJS loaders assign this return value so `cjs-module-lexer` — and
+  // therefore Node's CJS -> ESM named export detection — can see
+  // `__napiBindingTarget` statically.
+  return target
+}
+// Stamp before the alias, not after. The guard only reads `nativeBinding`
+// (`hasOwnProperty` plus a comparison), which is safe against any addon
+// accessor; an assignment is not, because a `#[napi(module_exports)]` hook can
+// expose a getter reporting this very value and a setter that throws. So the
+// assignment lands on the loader's own `module.exports`, still the original
+// object here, and the alias below replaces it.
+//
+// The assignment is what keeps the marker a statically visible CommonJS export:
+// `cjs-module-lexer` is Node's CJS -> ESM named export detection, it cannot see
+// a bare call, and the later `module.exports = nativeBinding` does not undo the
+// detection. The assignment itself always succeeds — its target is this
+// loader's own, still extensible `module.exports` — and the alias below then
+// discards the value it wrote. What a consumer reads is whatever the guard put
+// on `nativeBinding`, so on a frozen binding, where the guard skips, the
+// linked import resolves to `undefined`.
+module.exports.__napiBindingTarget = __napiStampBindingTarget(nativeBinding, __napiLoadedBindingTarget)
+module.exports = nativeBinding
+module.exports.Page = nativeBinding.Page
+module.exports.Scraper = nativeBinding.Scraper
+module.exports.ScrapeStream = nativeBinding.ScrapeStream
+module.exports.convert = nativeBinding.convert
+module.exports.convertAsync = nativeBinding.convertAsync
+module.exports.convertMany = nativeBinding.convertMany
+module.exports.PagesiftError = nativeBinding.PagesiftError
+module.exports.version = nativeBinding.version

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@pagesift/node",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.40.0",
+  "description": "Turn web pages into clean Markdown for LLMs: a polite, Firecrawl-compatible scraping engine written in Rust.",
+  "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YOLOW92/pagesift.git",
+    "directory": "crates/pagesift-node"
+  },
+  "keywords": [
+    "markdown",
+    "scraper",
+    "crawler",
+    "firecrawl",
+    "llm",
+    "html-to-markdown",
+    "napi-rs"
+  ],
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "engines": {
+    "node": ">= 18"
+  },
+  "napi": {
+    "binaryName": "pagesift",
+    "targets": [
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "x86_64-unknown-linux-musl",
+      "x86_64-pc-windows-msvc"
+    ],
+    "dtsHeaderFile": "header.d.ts"
+  },
+  "scripts": {
+    "build": "napi build --platform --release && node scripts/postbuild.mjs",
+    "build:debug": "napi build --platform && node scripts/postbuild.mjs",
+    "test": "node --test --test-concurrency=1",
+    "bench": "node bench/bench.mjs",
+    "artifacts": "napi artifacts",
+    "prepublishOnly": "napi prepublish -t npm --no-gh-release",
+    "version": "napi version"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "3.10.8"
+  },
+  "optionalDependencies": {
+    "@pagesift/node-linux-x64-gnu": "0.40.0",
+    "@pagesift/node-linux-arm64-gnu": "0.40.0",
+    "@pagesift/node-darwin-x64": "0.40.0",
+    "@pagesift/node-darwin-arm64": "0.40.0",
+    "@pagesift/node-linux-x64-musl": "0.40.0",
+    "@pagesift/node-win32-x64-msvc": "0.40.0"
+  }
+}