@opencraw/driver-client 0.2.10

package/README.md

@@ -0,0 +1,52 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/Open-Craw/OpenCraw/main/docs/assets/opencraw-logo.svg" alt="OpenCraw" width="360">
+</p>
+
+# @opencraw/driver-client
+
+A thin TypeScript client for [`@opencraw/driver`](../driver/README.md): it starts the driver program, speaks its
+JSON-RPC protocol over the pipes, and answers the driver's callouts with your functions. It is the reference
+client the conformance suite is held to, and the model every other language's package follows. To crawl from
+TypeScript in the same process, use [`@opencraw/core`](../core/README.md) instead.
+
+```sh
+npm install @opencraw/driver-client
+```
+
+```ts
+import { openDriver } from '@opencraw/driver-client'
+
+const driver = await openDriver({
+  hooks:         { tidy: input => String(input).trim().toLowerCase() },
+  accessPlugins: { pool: async ({ phase }) => phase === 'lease' ? { proxy: { server: 'http://proxy:8080' } } : {} },
+})
+
+const run = await driver.run({ paths: ['recipes/'], onRecord: ({ data }) => { console.log(data) } })
+const { report, error } = await run.finished
+
+await driver.close()
+```
+
+- **What you serve is registered once**, by name: `hooks`, `captchaSolvers` and `accessPlugins`. Every run,
+  worker pool and probe may use them; a handler's return value is the callout's answer, and a handler that
+  throws answers `error` with its message, which fails that call, not the run.
+- **`run`** answers once the driver has started it; `onEvent` and `onRecord` stream as it crawls, and
+  `finished` settles with the report (it never rejects). `cancel()` stops it.
+- **`work`** is worker mode: `next()` gives each window its item (`{ id, vars }`), and may wait until there is
+  one; `null` ends the work. `onDone` and `onFailed` say how each item ended.
+- **`validate`, `probe`, `diff`, `export`** answer as the driver's methods do.
+- **`close`** asks the driver to shut down and waits for it to exit.
+
+The driver program is the installed `@opencraw/driver`'s, run with this Node; `command` starts another one, and
+`runtime: { version }` starts a release's own runtime, which needs no Node: `ensureDriverRuntime` downloads this
+platform's archive once (named in the release's `driver-runtime.json`), refuses it when its SHA-256 differs,
+and unpacks it into `~/.cache/opencraw/driver/<version>/<platform>/`. `OPENCRAW_DRIVER=<folder>` uses an
+unpacked runtime as it is, and `OPENCRAW_DRIVER_OFFLINE=1` (or `offline: true`) never downloads: a runtime not
+already cached is an error. Every client in another language follows the same steps.
+
+## Development
+
+`smith test -p driver,driver-client`. The client's tests start the built driver program: they run a crawl
+and a worker pool against a local site, a probe through a served access plugin, and every transcript in
+`packages/driver/conformance/` over the program's pipes. The `driver-conformance` workflow runs them on
+Linux, macOS and Windows.

package/dist/index.esm.js

@@ -0,0 +1,205 @@
+// src/driver-session/open-driver.use-case.ts
+import { once } from "node:events";
+import { openLineChannel, PROTOCOL_VERSION } from "@opencraw/driver";
+
+// src/driver-process/driver-process.client.ts
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+function installedDriverCommand() {
+  const manifest = createRequire(import.meta.url).resolve("@opencraw/driver/package.json");
+  const { bin } = JSON.parse(readFileSync(manifest, "utf8"));
+  return [process.execPath, join(dirname(manifest), bin["opencraw-driver"])];
+}
+function startDriverProcess(options = {}) {
+  const [program, ...args] = options.command ?? installedDriverCommand();
+  const child = spawn(program, args, { env: options.env ?? process.env, cwd: options.cwd, stdio: ["pipe", "pipe", options.stderr ?? "inherit"], windowsHide: true });
+  if (child.stdin === null || child.stdout === null) throw new Error("the driver started without its pipes");
+  const exited = new Promise((resolve2, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      resolve2(code);
+    });
+  });
+  return {
+    input: child.stdin,
+    output: child.stdout,
+    ...child.stderr !== null && { logs: child.stderr },
+    exited,
+    kill: () => {
+      child.kill();
+    }
+  };
+}
+
+// src/driver-runtime/ensure-driver-runtime.use-case.ts
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { mkdir, mkdtemp, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join as join2, resolve } from "node:path";
+import { runtimeManifestSchema } from "@opencraw/driver";
+var RELEASES_URL = "https://github.com/Open-Craw/OpenCraw/releases/download";
+async function ensureDriverRuntime(options) {
+  const env = options.env ?? process.env;
+  if (env.OPENCRAW_DRIVER !== void 0 && env.OPENCRAW_DRIVER !== "") return runtimeIn(resolve(env.OPENCRAW_DRIVER));
+  const platform = options.platform ?? `${process.platform}-${process.arch}`;
+  const cache = options.cacheDir ?? join2(homedir(), ".cache", "opencraw", "driver");
+  const folder = join2(cache, options.version, platform);
+  if (existsSync(join2(folder, "runtime.json"))) return runtimeIn(folder);
+  if (options.offline ?? env.OPENCRAW_DRIVER_OFFLINE === "1") throw new Error(`driver ${options.version} for ${platform} is not in ${cache}, and downloading is off (OPENCRAW_DRIVER_OFFLINE)`);
+  const get = options.fetch ?? fetch;
+  const release = `${options.baseUrl ?? RELEASES_URL}/${encodeURIComponent(`driver@${options.version}`)}`;
+  const listing = await download(get, `${release}/driver-runtime.json`);
+  const manifest = runtimeManifestSchema.parse(await listing.json());
+  const archive = manifest.archives[platform];
+  if (archive === void 0) throw new Error(`driver ${options.version} has no runtime for ${platform}: it has ${Object.keys(manifest.archives).join(", ")}`);
+  const fetched = await download(get, `${release}/${archive.file}`);
+  const bytes = Buffer.from(await fetched.arrayBuffer());
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  if (sha256 !== archive.sha256) throw new Error(`${archive.file} does not match driver-runtime.json (sha256 ${sha256}, expected ${archive.sha256}): refusing it`);
+  await mkdir(join2(cache, options.version), { recursive: true });
+  const unpacking = await mkdtemp(join2(cache, options.version, `.${platform}-`));
+  try {
+    await writeFile(join2(unpacking, archive.file), bytes);
+    execFileSync("tar", ["-xzf", archive.file], { cwd: unpacking, stdio: "ignore" });
+    await rm(join2(unpacking, archive.file));
+    await rename(unpacking, folder);
+  } catch (error) {
+    await rm(unpacking, { recursive: true, force: true });
+    if (existsSync(join2(folder, "runtime.json"))) return runtimeIn(folder);
+    throw error;
+  }
+  return runtimeIn(folder);
+}
+async function download(get, url) {
+  const response = await get(url);
+  if (!response.ok) throw new Error(`GET ${url}: ${String(response.status)} ${response.statusText}`);
+  return response;
+}
+function runtimeIn(folder) {
+  const { command } = JSON.parse(readFileSync2(join2(folder, "runtime.json"), "utf8"));
+  const [program, ...args] = command.map((part) => join2(folder, part));
+  return { folder, command: [program, ...args] };
+}
+
+// src/driver-session/answer-callout.use-case.ts
+async function answerCallout(request, handlers) {
+  try {
+    if (request.kind === "hook") {
+      const hook = handlers.hooks?.[request.name];
+      if (hook === void 0) return { status: "error", error: `this client serves no hook "${request.name}"` };
+      return { status: "ok", output: await hook(request.input, request.args, request) };
+    }
+    if (request.kind === "captcha") {
+      const solver = handlers.captchaSolvers?.[request.name];
+      if (solver === void 0) return { status: "error", error: `this client serves no captcha solver "${request.name}"` };
+      return { status: "ok", output: await solver(request.input, request) };
+    }
+    const plugin = handlers.accessPlugins?.[request.name];
+    if (plugin === void 0) return { status: "error", error: `this client serves no access plugin "${request.name}"` };
+    return { status: "ok", output: await plugin(request.input, request) };
+  } catch (error) {
+    return { status: "error", error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/driver-session/open-driver.use-case.ts
+async function openDriver(options = {}) {
+  const runtime = options.command === void 0 && options.runtime !== void 0 ? await ensureDriverRuntime(options.runtime) : void 0;
+  const command = options.command ?? runtime?.command;
+  const driver = startDriverProcess({ ...options, command });
+  const routes = /* @__PURE__ */ new Map();
+  let closing;
+  const handlers = { hooks: options.hooks, captchaSolvers: options.captchaSolvers, accessPlugins: options.accessPlugins };
+  const served = {
+    hooks: Object.keys(options.hooks ?? {}),
+    captchaSolvers: Object.keys(options.captchaSolvers ?? {}),
+    accessPlugins: Object.keys(options.accessPlugins ?? {})
+  };
+  const routed = new EventTarget();
+  const routeOf = async (runId) => {
+    const known = routes.get(runId);
+    if (known !== void 0) return known;
+    await once(routed, runId);
+    return routes.get(runId);
+  };
+  const deliver = {
+    "work.next": async (route) => ({ item: await route.work?.next() ?? null }),
+    "event": (route, message) => route.onEvent?.(message.event),
+    "record": (route, message) => route.onRecord?.(withoutRunId(message)),
+    "work.done": (route, message) => route.work?.onDone?.(withoutRunId(message)),
+    "work.failed": (route, message) => route.work?.onFailed?.(withoutRunId(message)),
+    "finished": (route, message) => {
+      routes.delete(message.runId);
+      route.finish(withoutRunId(message));
+    }
+  };
+  const channel = openLineChannel(driver.output, driver.input, async (method, params) => {
+    const message = params;
+    if (method === "callout") return await answerCallout(message.request, handlers);
+    if (!Object.hasOwn(deliver, method)) return null;
+    const answer = await deliver[method](await routeOf(message.runId), message);
+    return method === "work.next" ? answer : null;
+  });
+  const ask = async (method, params) => await channel.request(method, params);
+  const info = await ask("initialize", { clientName: options.clientName ?? "@opencraw/driver-client", clientVersion: options.clientVersion ?? "0.0.0", protocolVersion: PROTOCOL_VERSION });
+  const start = async (method, params, route) => {
+    const { runId } = await ask(method, { ...params, ...served });
+    const ending = new EventTarget();
+    const finished = (async () => {
+      const [event] = await once(ending, "finished");
+      return event.detail;
+    })();
+    routes.set(runId, { ...route, finish: (detail) => {
+      ending.dispatchEvent(new CustomEvent("finished", { detail }));
+    } });
+    routed.dispatchEvent(new Event(runId));
+    return {
+      runId,
+      finished,
+      cancel: async () => {
+        const answer = await ask("cancel", { runId });
+        return answer.cancelled;
+      }
+    };
+  };
+  return {
+    info,
+    validate: async (params) => await ask("validate", params),
+    run: async ({ onEvent, onRecord, ...params }) => await start("run", params, { onEvent, onRecord }),
+    work: async (work) => {
+      const { onEvent, onRecord, next, onDone, onFailed, ...params } = work;
+      return await start("work", params, { onEvent, onRecord, work: { next, onDone, onFailed } });
+    },
+    probe: async (params) => await ask("probe", { ...params, accessPlugins: served.accessPlugins }),
+    diff: async (params) => await ask("diff", params),
+    export: async (params) => await ask("export", params),
+    close: async () => {
+      closing ??= (async () => {
+        try {
+          await ask("shutdown");
+        } catch {
+        }
+        driver.input.end();
+        await driver.exited;
+      })();
+      await closing;
+    }
+  };
+}
+function withoutRunId(message) {
+  const { runId: _runId, ...rest } = message;
+  return rest;
+}
+export {
+  RELEASES_URL,
+  answerCallout,
+  ensureDriverRuntime,
+  installedDriverCommand,
+  openDriver,
+  startDriverProcess
+};
+//# sourceMappingURL=index.esm.js.map

package/dist/src/driver-process/driver-process.client.d.ts

@@ -0,0 +1,39 @@
+import type { Readable, Writable } from 'node:stream';
+/** How to start the driver. */
+export interface DriverProcessOptions {
+    /** The program and its arguments; default: Node running the installed `@opencraw/driver`'s `opencraw-driver`. */
+    command?: readonly [string, ...string[]];
+    /** Its environment; default: this process's. */
+    env?: NodeJS.ProcessEnv;
+    /** Its working directory; default: this process's. */
+    cwd?: string;
+    /** Where its stderr (its logs) goes; default: this process's stderr. */
+    stderr?: 'inherit' | 'ignore' | 'pipe';
+}
+/** A started driver: its pipes, and how it ends. */
+export interface DriverProcess {
+    /** Its stdin: messages to it. */
+    input: Writable;
+    /** Its stdout: messages from it. */
+    output: Readable;
+    /** Its stderr, when `stderr` was `pipe`. */
+    logs?: Readable;
+    /** Settles with its exit code (null when a signal ended it). */
+    exited: Promise<number | null>;
+    /** Ends it at once, without `shutdown`. */
+    kill: () => void;
+}
+/**
+ * The installed driver's program: the `opencraw-driver` bin of `@opencraw/driver`, run with this Node.
+ *
+ * @returns The command.
+ */
+export declare function installedDriverCommand(): [string, string];
+/**
+ * Starts the driver as a child process, its stdin and stdout the protocol's pipes.
+ *
+ * @param options - The command, environment, working directory and where its logs go.
+ * @returns The process.
+ */
+export declare function startDriverProcess(options?: DriverProcessOptions): DriverProcess;
+//# sourceMappingURL=driver-process.client.d.ts.map

package/dist/src/driver-process/index.d.ts

@@ -0,0 +1,3 @@
+export { installedDriverCommand, startDriverProcess } from './driver-process.client.js';
+export type { DriverProcess, DriverProcessOptions } from './driver-process.client.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/driver-runtime/ensure-driver-runtime.use-case.d.ts

@@ -0,0 +1,36 @@
+/** Where the driver's releases are: `<base>/driver@<version>/driver-runtime.json` and the archives beside it. */
+export declare const RELEASES_URL = "https://github.com/Open-Craw/OpenCraw/releases/download";
+/** Which runtime to use, and where it may come from. */
+export interface DriverRuntimeOptions {
+    /** The driver release (`0.6.0`). */
+    version: string;
+    /** Default: `~/.cache/opencraw/driver`. */
+    cacheDir?: string;
+    /** Refuse to download (default: `OPENCRAW_DRIVER_OFFLINE=1`). */
+    offline?: boolean;
+    /** Default: `<process.platform>-<process.arch>`. */
+    platform?: string;
+    /** Default: the project's GitHub releases. */
+    baseUrl?: string;
+    /** Where `OPENCRAW_DRIVER` and `OPENCRAW_DRIVER_OFFLINE` are read. */
+    env?: NodeJS.ProcessEnv;
+    fetch?: typeof fetch;
+}
+/** A runtime ready to start: its folder and the command, absolute. */
+export interface DriverRuntime {
+    folder: string;
+    command: [string, ...string[]];
+}
+/**
+ * The driver's runtime for this platform, downloaded once into a per-user cache: what lets a client run
+ * the driver with no Node of its own. `OPENCRAW_DRIVER` names an unpacked runtime to use as it is. A
+ * cached one is used as it is. Otherwise, unless offline, the release's `driver-runtime.json` names this
+ * platform's archive; it is downloaded, refused when its SHA-256 differs, unpacked into a temporary
+ * folder and moved into the cache in one step, so a half-written runtime is never used.
+ *
+ * @param options - The version, and where the runtime may come from.
+ * @returns The runtime's folder and its command.
+ * @throws Error When offline and not cached, when the release has no archive for the platform, or when the archive's hash is wrong.
+ */
+export declare function ensureDriverRuntime(options: DriverRuntimeOptions): Promise<DriverRuntime>;
+//# sourceMappingURL=ensure-driver-runtime.use-case.d.ts.map

package/dist/src/driver-runtime/index.d.ts

@@ -0,0 +1,3 @@
+export { ensureDriverRuntime, RELEASES_URL } from './ensure-driver-runtime.use-case.js';
+export type { DriverRuntime, DriverRuntimeOptions } from './ensure-driver-runtime.use-case.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/driver-session/answer-callout.use-case.d.ts

@@ -0,0 +1,14 @@
+import type { CalloutRequest, CalloutResponse } from '@opencraw/core';
+import type { ClientHandlers } from './driver-client.contract.js';
+/**
+ * Answers a `callout` the driver sent: the handler registered for its kind and name answers it, and
+ * what the handler returns is the `ok` answer's output. A handler that throws answers `error` with its
+ * message, and a name nothing is registered for answers `error` too, so a run fails the call, not the
+ * channel.
+ *
+ * @param request - Core's callout request, as the driver sent it.
+ * @param handlers - What the client serves.
+ * @returns The callout response.
+ */
+export declare function answerCallout(request: CalloutRequest, handlers: ClientHandlers): Promise<CalloutResponse>;
+//# sourceMappingURL=answer-callout.use-case.d.ts.map

package/dist/src/driver-session/driver-client.contract.d.ts

@@ -0,0 +1,68 @@
+import type { AccessCalloutInput, AccessCalloutOutput, CalloutRequest, CaptchaCalloutInput, CaptchaCalloutOutput, CrawlEvent, CrawlReport, WorkReport } from '@opencraw/core';
+import type { DiffParams, DiffResult, ExportParams, ExportResult, FinishedParams, InitializeResult, ProbeParams, RecordParams, RunParams, ValidateParams, ValidateResult, WorkDoneParams, WorkFailedParams, WorkItemMessage, WorkParams } from '@opencraw/driver';
+import type { DriverProcessOptions } from '../driver-process/index.js';
+import type { DriverRuntimeOptions } from '../driver-runtime/index.js';
+/** A hook the client serves: the value the recipe passes, its arguments, and the whole request. */
+export type HookHandler = (input: unknown, args: Record<string, unknown>, request: CalloutRequest) => unknown;
+/** A captcha solver the client serves: the challenge, answered with a `token` or the `text` to type. */
+export type CaptchaHandler = (input: CaptchaCalloutInput, request: CalloutRequest) => CaptchaCalloutOutput | Promise<CaptchaCalloutOutput>;
+/** An access plugin the client serves: a lease (`phase: "lease"`), or the release of one (`phase: "release"`). */
+export type AccessHandler = (input: AccessCalloutInput, request: CalloutRequest) => AccessCalloutOutput | Promise<AccessCalloutOutput>;
+/** What the client serves, by name. Every run and probe may use any of them. */
+export interface ClientHandlers {
+    hooks?: Record<string, HookHandler>;
+    captchaSolvers?: Record<string, CaptchaHandler>;
+    accessPlugins?: Record<string, AccessHandler>;
+}
+/** How to start a driver and talk to it. */
+export interface OpenDriverOptions extends DriverProcessOptions, ClientHandlers {
+    /** The name the client gives the driver in `initialize`. */
+    clientName?: string;
+    clientVersion?: string;
+    /** Run the downloaded runtime of this release (no Node needed) instead of the installed `@opencraw/driver`; ignored when `command` is given. */
+    runtime?: DriverRuntimeOptions;
+}
+/** What a run streams back, as it happens. */
+export interface RunCallbacks {
+    onEvent?: (event: CrawlEvent) => void;
+    /** Each record, unless the run has `out`. */
+    onRecord?: (record: Omit<RecordParams, 'runId'>) => void;
+}
+/** A run's options: the protocol's, without the names of what the client serves (it serves all it registered). */
+export type RunOptions = Omit<RunParams, 'hooks' | 'captchaSolvers' | 'accessPlugins'> & RunCallbacks;
+/** A worker pool's options: where its items come from, and how each ended. */
+export type WorkOptions = Omit<WorkParams, 'hooks' | 'captchaSolvers' | 'accessPlugins'> & RunCallbacks & {
+    /** The next item for a window, waiting until there is one; `null` ends the work. */
+    next: () => Promise<WorkItemMessage | null> | WorkItemMessage | null;
+    onDone?: (done: Omit<WorkDoneParams, 'runId'>) => void;
+    onFailed?: (failed: Omit<WorkFailedParams, 'runId'>) => void;
+};
+/** A probe's options, without the names of the access plugins the client serves. */
+export type ProbeOptions = Omit<ProbeParams, 'accessPlugins'>;
+/** A run (or a worker pool) the driver is crawling. */
+export interface RunHandle<Report> {
+    runId: string;
+    /** Settles when it ends: its report, or why it could not run (it never rejects). */
+    finished: Promise<{
+        report?: Report;
+        error?: string;
+    }>;
+    /** Stops it; it still ends through `finished`. */
+    cancel: () => Promise<boolean>;
+}
+/** A started driver. */
+export interface OpenCrawDriver {
+    /** What the driver said in `initialize`. */
+    info: InitializeResult;
+    validate: (params: ValidateParams) => Promise<ValidateResult>;
+    run: (options: RunOptions) => Promise<RunHandle<CrawlReport>>;
+    work: (options: WorkOptions) => Promise<RunHandle<WorkReport>>;
+    probe: (options: ProbeOptions) => Promise<Record<string, unknown>>;
+    diff: (params: DiffParams) => Promise<DiffResult>;
+    export: (params: ExportParams) => Promise<ExportResult>;
+    /** Asks for `shutdown` and waits for the process to exit. */
+    close: () => Promise<void>;
+}
+/** A `finished` notification, without its run id. */
+export type Finished = Omit<FinishedParams, 'runId'>;
+//# sourceMappingURL=driver-client.contract.d.ts.map

package/dist/src/driver-session/index.d.ts

@@ -0,0 +1,4 @@
+export { openDriver } from './open-driver.use-case.js';
+export { answerCallout } from './answer-callout.use-case.js';
+export type { AccessHandler, CaptchaHandler, ClientHandlers, HookHandler, OpenCrawDriver, OpenDriverOptions, ProbeOptions, RunCallbacks, RunHandle, RunOptions, WorkOptions, } from './driver-client.contract.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/driver-session/open-driver.use-case.d.ts

@@ -0,0 +1,13 @@
+import type { OpenCrawDriver, OpenDriverOptions } from './driver-client.contract.js';
+/**
+ * Starts a driver and initializes it: the thin client the conformance suite is held to, and a way to
+ * drive the engine from another process. Hooks, captcha solvers and access plugins are registered once
+ * here, by name; every run, worker pool and probe may use them, and the driver asks for them through
+ * `callout` requests. A run streams through its callbacks and settles `finished`.
+ *
+ * @param options - How to start the driver, and what the client serves.
+ * @returns The driver, initialized.
+ * @throws RpcFailure When the driver refuses `initialize` (another protocol major).
+ */
+export declare function openDriver(options?: OpenDriverOptions): Promise<OpenCrawDriver>;
+//# sourceMappingURL=open-driver.use-case.d.ts.map

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export { openDriver } from './driver-session/index.js';
+export type { AccessHandler, CaptchaHandler, ClientHandlers, HookHandler, OpenCrawDriver, OpenDriverOptions, ProbeOptions, RunCallbacks, RunHandle, RunOptions, WorkOptions, } from './driver-session/index.js';
+export { ensureDriverRuntime, RELEASES_URL } from './driver-runtime/index.js';
+export type { DriverRuntime, DriverRuntimeOptions } from './driver-runtime/index.js';
+export { installedDriverCommand, startDriverProcess } from './driver-process/index.js';
+export type { DriverProcess, DriverProcessOptions } from './driver-process/index.js';
+export { answerCallout } from './driver-session/index.js';
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@opencraw/driver-client",
+  "version": "0.2.10",
+  "description": "A thin TypeScript client for OpenCraw's driver: the conformance suite's reference client, and a way to drive the engine from another process",
+  "license": "MIT",
+  "type": "module",
+  "smith": {
+    "kind": "package",
+    "stack": "node-vitest"
+  },
+  "main": "./dist/index.esm.js",
+  "module": "./dist/index.esm.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/index.esm.js",
+      "default": "./dist/index.esm.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "!**/*.d.ts.map",
+    "!**/*.js.map"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --packages=external --platform=node --format=esm --outdir=dist --out-extension:.js=.esm.js --sourcemap && tsc -p tsconfig.build.json && node ../../declaration-specifiers.mjs dist/src",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint": "eslint .",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@opencraw/core": "^0.5.0",
+    "@opencraw/driver": "^0.7.10"
+  }
+}