@opencraw/driver 0.1.0 → 0.3.0

package/README.md

@@ -17,8 +17,8 @@ npx opencraw-driver   # then write JSON-RPC lines to it
 ## The conversation
 
 ```jsonc
-→ {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"clientName":"opencraw-python","clientVersion":"1.0.0","protocolVersion":"1.0.0"}}
-← {"jsonrpc":"2.0","id":1,"result":{"driverVersion":"0.1.0","protocolVersion":"1.0.0","methods":["initialize","validate","run","cancel","shutdown"]}}
+→ {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"clientName":"opencraw-python","clientVersion":"1.0.0","protocolVersion":"1.2.0"}}
+← {"jsonrpc":"2.0","id":1,"result":{"driverVersion":"0.2.0","protocolVersion":"1.2.0","methods":["initialize","validate","run","work","cancel","probe","diff","export","shutdown"]}}
 → {"jsonrpc":"2.0","id":2,"method":"run","params":{"paths":["recipes/"],"hooks":["tidy"]}}
 ← {"jsonrpc":"2.0","id":2,"result":{"runId":"run-1"}}
 ← {"jsonrpc":"2.0","method":"event","params":{"runId":"run-1","event":{"type":"recipe:start",…}}}
@@ -33,13 +33,19 @@ npx opencraw-driver   # then write JSON-RPC lines to it
 |---|---|---|
 | `initialize` | client | Must come first. The driver refuses a protocol of another major. |
 | `validate` | client | Loads recipes (`paths` or inline `recipes`) without running them: the inputs that would run, every hook they call, and every problem with its path. |
-| `run` | client | Starts a run and answers its `runId` at once; the crawl goes on in the background. `hooks` names the hooks the client answers; `out` writes records to a file instead of sending them. |
+| `run` | client | Starts a run and answers its `runId` at once; the crawl goes on in the background. `hooks`, `captchaSolvers` and `accessPlugins` name what the client answers; `accessConfig` and `access` pick the access config and profile; `out` writes records to a file instead of sending them. |
+| `work` | client | Starts a worker pool and answers its `runId` at once. Its windows ask the client for items (`work.next`) and keep the steps marked `keep` between them; `windows` is a count or core's `WindowsPolicy`. Takes the same crawler fields as `run`. |
 | `cancel` | client | Stops a run (its crawler is closed); it still ends with `finished`. |
+| `probe` | client | Fetches a page (or renders it, with `browser`) and says where its data lives: the CLI's and MCP's probe, through the same access fields as `run`. |
+| `diff` | client | Compares two runs' JSON Lines files by key: counts, the report a person reads, and the changes up to `limit`. |
+| `export` | client | Writes a run's JSON Lines file in another format (the extension of `out`), with an output recipe's columns. |
 | `shutdown` | client | Closes every run, answers, then exits. Closing stdin does the same. |
 | `event` | driver | Every crawl event, as core reports it. |
 | `record` | driver | Each record, unless the run has `out`. |
-| `finished` | driver | The run is over: its report, or why it could not run. |
-| `callout` | driver | A hook the client serves. The request and its answer are core's [callout contract](../core/README.md): `ok`, `error`, or `pending` with `retryAfterMs`, asked again with the same idempotency key. |
+| `finished` | driver | The run is over: its report (for `work`, the work report), or why it could not run. |
+| `work.next` | driver | A window wants an item: answer `{ "item": { "id", "vars", "recipe"? } }`, holding the answer until there is one, or `{ "item": null }` to end the work. An id already queued or running runs once. |
+| `work.done`, `work.failed` | driver | How an item ended: its report and records, or its outcome (`failure`, `neutral`). |
+| `callout` | driver | A hook, captcha solver or access plugin the client serves (`request.kind`: `hook`, `captcha`, `access`). The request and its answer are core's [callout contract](../core/README.md): `ok`, `error`, or `pending` with `retryAfterMs`, asked again with the same idempotency key. |
 
 Every answer comes back before the driver stops, even when a client writes its last requests and closes
 stdin at once. Answers may arrive out of order; match them by `id`.

package/dist/index.esm.js

@@ -1,11 +1,18 @@
 // src/server/serve-driver.use-case.ts
-import { once } from "node:events";
+import { once as once2 } from "node:events";
 
 // src/protocol/driver-message.contract.ts
 import { calloutRequestSchema, calloutResponseSchema } from "@opencraw/core";
 import { z } from "zod";
-var PROTOCOL_VERSION = "1.0.0";
+var PROTOCOL_VERSION = "1.2.0";
 var recipeObject = z.record(z.string(), z.unknown());
+var coreObject = z.record(z.string(), z.unknown());
+var accessFields = {
+  accessConfig: z.string().optional(),
+  access: z.string().optional(),
+  /** Access plugins the client serves: a profile `{ "kind": "plugin", "name": … }` naming one leases through a `callout` to the client. */
+  accessPlugins: z.array(z.string()).optional()
+};
 var recipeSource = {
   paths: z.array(z.string()).min(1).optional(),
   recipes: z.array(recipeObject).min(1).optional()
@@ -41,17 +48,87 @@ var runParamsSchema = z.strictObject({
   parallel: z.number().int().min(1).max(16).optional(),
   browser: z.strictObject({ headless: z.boolean().optional(), executablePath: z.string().optional(), ignoreHTTPSErrors: z.boolean().optional() }).optional(),
   /** The hooks the client answers itself: each becomes a `callout` request to the client when a recipe calls it. */
-  hooks: z.array(z.string()).optional()
+  hooks: z.array(z.string()).optional(),
+  /** Captcha solvers the client serves, by name: a challenge goes to the client as a `captcha` callout. */
+  captchaSolvers: z.array(z.string()).optional(),
+  ...accessFields
 });
 var runResultSchema = z.strictObject({ runId: z.string() });
+var windowsSchema = z.union([z.number().int().min(1).max(64), z.record(z.string(), z.unknown())]);
+var workParamsSchema = z.strictObject({
+  ...recipeSource,
+  only: z.array(z.string()).optional(),
+  out: z.string().optional(),
+  append: z.boolean().optional(),
+  browser: z.strictObject({ headless: z.boolean().optional(), executablePath: z.string().optional(), ignoreHTTPSErrors: z.boolean().optional() }).optional(),
+  hooks: z.array(z.string()).optional(),
+  captchaSolvers: z.array(z.string()).optional(),
+  ...accessFields,
+  windows: windowsSchema.optional()
+});
+var varValue = z.union([z.string(), z.number(), z.boolean()]);
+var workItemSchema = z.strictObject({
+  id: z.string().min(1),
+  vars: z.record(z.string(), varValue),
+  recipe: z.string().optional()
+});
 var cancelParamsSchema = z.strictObject({ runId: z.string() });
 var cancelResultSchema = z.strictObject({ cancelled: z.boolean() });
+var probeParamsSchema = z.strictObject({
+  url: z.string().min(1),
+  /** Render the page in Chromium first (for pages built by scripts). */
+  browser: z.boolean().optional(),
+  browserPath: z.string().optional(),
+  insecureTls: z.boolean().optional(),
+  userAgent: z.string().optional(),
+  ...accessFields
+});
+var probeResultSchema = coreObject;
+var diffParamsSchema = z.strictObject({
+  /** The earlier run's JSON Lines file. */
+  previous: z.string().min(1),
+  current: z.string().min(1),
+  /** The fields that identify a record; default: each line's `_key`. */
+  key: z.array(z.string()).optional(),
+  /** Fields left out of the comparison. */
+  ignore: z.array(z.string()).optional(),
+  /** Changes returned at most (default 200); the counts cover all of them. */
+  limit: z.number().int().min(0).optional()
+});
+var diffResultSchema = z.strictObject({
+  added: z.number(),
+  removed: z.number(),
+  changed: z.number(),
+  unchanged: z.number(),
+  /** Set when the current run lost most of the previous run's records. */
+  shrunk: z.strictObject({ previous: z.number(), current: z.number() }).optional(),
+  /** The report a person reads, one line per change. */
+  summary: z.array(z.string()),
+  /** The changes, up to `limit`: each `added`, `removed` or `changed` (with each field's before and after). */
+  changes: z.array(coreObject),
+  /** More changes than `limit` were found. */
+  truncated: z.boolean()
+});
+var exportParamsSchema = z.strictObject({
+  /** A run's JSON Lines file. */
+  records: z.string().min(1),
+  /** The output recipe that gives the columns. */
+  output: z.string().min(1),
+  /** The file to write; its extension names the format, as for `run`. */
+  out: z.string().min(1)
+});
+var exportResultSchema = z.strictObject({ written: z.number(), location: z.string() });
 var shutdownResultSchema = z.strictObject({});
+var workNextParamsSchema = z.strictObject({ runId: z.string() });
+var workNextResultSchema = z.strictObject({ item: workItemSchema.nullable() });
+var workRecordSchema = z.strictObject({ key: z.string().nullable(), data: z.record(z.string(), z.unknown()) });
+var workDoneParamsSchema = z.strictObject({ runId: z.string(), item: workItemSchema, report: coreObject, records: z.array(workRecordSchema) });
+var workFailedParamsSchema = z.strictObject({ runId: z.string(), item: workItemSchema, report: coreObject, outcome: z.enum(["failure", "neutral"]) });
 var eventParamsSchema = z.strictObject({ runId: z.string(), event: z.record(z.string(), z.unknown()) });
 var recordParamsSchema = z.strictObject({ runId: z.string(), recipeId: z.string(), key: z.string().nullable(), data: z.record(z.string(), z.unknown()) });
 var finishedParamsSchema = z.strictObject({
   runId: z.string(),
-  /** The crawl report (`CrawlReport`), absent when the run could not start. */
+  /** The crawl report (`CrawlReport`), or for `work` the work report (`WorkReport`); absent when the run could not start. */
   report: z.record(z.string(), z.unknown()).optional(),
   /** Why the run could not start, or stopped as a whole. */
   error: z.string().optional()
@@ -59,15 +136,22 @@ var finishedParamsSchema = z.strictObject({
 var calloutParamsSchema = z.strictObject({ runId: z.string(), request: calloutRequestSchema });
 var calloutResultSchema = calloutResponseSchema;
 var MESSAGES = {
-  initialize: { direction: "client-to-driver", params: initializeParamsSchema, result: initializeResultSchema },
-  validate: { direction: "client-to-driver", params: validateParamsSchema, result: validateResultSchema },
-  run: { direction: "client-to-driver", params: runParamsSchema, result: runResultSchema },
-  cancel: { direction: "client-to-driver", params: cancelParamsSchema, result: cancelResultSchema },
-  shutdown: { direction: "client-to-driver", params: void 0, result: shutdownResultSchema },
-  callout: { direction: "driver-to-client", params: calloutParamsSchema, result: calloutResultSchema },
-  event: { direction: "driver-to-client", params: eventParamsSchema, result: void 0 },
-  record: { direction: "driver-to-client", params: recordParamsSchema, result: void 0 },
-  finished: { direction: "driver-to-client", params: finishedParamsSchema, result: void 0 }
+  "initialize": { direction: "client-to-driver", params: initializeParamsSchema, result: initializeResultSchema },
+  "validate": { direction: "client-to-driver", params: validateParamsSchema, result: validateResultSchema },
+  "run": { direction: "client-to-driver", params: runParamsSchema, result: runResultSchema },
+  "work": { direction: "client-to-driver", params: workParamsSchema, result: runResultSchema },
+  "cancel": { direction: "client-to-driver", params: cancelParamsSchema, result: cancelResultSchema },
+  "probe": { direction: "client-to-driver", params: probeParamsSchema, result: probeResultSchema },
+  "diff": { direction: "client-to-driver", params: diffParamsSchema, result: diffResultSchema },
+  "export": { direction: "client-to-driver", params: exportParamsSchema, result: exportResultSchema },
+  "shutdown": { direction: "client-to-driver", params: void 0, result: shutdownResultSchema },
+  "callout": { direction: "driver-to-client", params: calloutParamsSchema, result: calloutResultSchema },
+  "work.next": { direction: "driver-to-client", params: workNextParamsSchema, result: workNextResultSchema },
+  "work.done": { direction: "driver-to-client", params: workDoneParamsSchema, result: void 0 },
+  "work.failed": { direction: "driver-to-client", params: workFailedParamsSchema, result: void 0 },
+  "event": { direction: "driver-to-client", params: eventParamsSchema, result: void 0 },
+  "record": { direction: "driver-to-client", params: recordParamsSchema, result: void 0 },
+  "finished": { direction: "driver-to-client", params: finishedParamsSchema, result: void 0 }
 };
 
 // src/protocol/driver-json-schema.mapper.ts
@@ -99,19 +183,127 @@ function driverProtocolJsonSchema() {
   };
 }
 
+// src/record-files/diff-record-files.use-case.ts
+import { diffReport } from "@opencraw/cli";
+import { diffRecords, readRecordsFile } from "@opencraw/core";
+var CHANGE_LIMIT = 200;
+async function diffRecordFiles(params) {
+  const [previous, current] = await Promise.all([readRecordsFile(params.previous), readRecordsFile(params.current)]);
+  const diff = diffRecords(previous, current, { key: params.key, ignore: params.ignore });
+  const limit = params.limit ?? CHANGE_LIMIT;
+  return {
+    added: diff.added,
+    removed: diff.removed,
+    changed: diff.changed,
+    unchanged: diff.unchanged,
+    ...diff.shrunk !== void 0 && { shrunk: diff.shrunk },
+    summary: diffReport(diff),
+    changes: diff.changes.slice(0, limit).map((change) => ({ ...change })),
+    truncated: diff.changes.length > limit
+  };
+}
+
+// src/record-files/export-record-files.use-case.ts
+import { readFile } from "node:fs/promises";
+import { fileSink, outputRecordOf, parseOutputRecipe, readRecordsFile as readRecordsFile2 } from "@opencraw/core";
+async function exportRecordFiles(params) {
+  const output = parseOutputRecipe(JSON.parse(await readFile(params.output, "utf8")), params.output);
+  const stored = await readRecordsFile2(params.records);
+  const sink = fileSink(params.out, { browser: { executablePath: process.env.OPENCRAW_CHROMIUM } });
+  await sink.open(output);
+  for (const line of stored) await sink.write(outputRecordOf(line));
+  const summary = await sink.close();
+  return { written: summary.written, location: summary.location ?? params.out };
+}
+
 // src/session/run-session.use-case.ts
-import { createCrawler, fileSink, RecipeSet } from "@opencraw/core";
+import { createCrawler, fileSink as fileSink2, RecipeSet } from "@opencraw/core";
 
 // src/callout-bridge/client-hooks.client.ts
-import { calloutHook, calloutResponseSchema as calloutResponseSchema2 } from "@opencraw/core";
-function clientTransport(hookName, runId, ask) {
+import { accessPluginVia, calloutHook, calloutResponseSchema as calloutResponseSchema2, captchaSolverVia } from "@opencraw/core";
+function clientTransport(label, runId, ask) {
   return {
-    label: `client hook ${hookName}`,
+    label,
     call: async (request) => calloutResponseSchema2.parse(await ask("callout", { runId, request }))
   };
 }
 function clientHooks(names, runId, ask) {
-  return Object.fromEntries(names.map((name) => [name, calloutHook(name, clientTransport(name, runId, ask))]));
+  return Object.fromEntries(names.map((name) => [name, calloutHook(name, clientTransport(`client hook ${name}`, runId, ask))]));
+}
+function clientCaptchaSolvers(names, runId, ask) {
+  return names.map((name) => captchaSolverVia(name, clientTransport(`client captcha solver ${name}`, runId, ask)));
+}
+function clientAccessPlugins(names, runId, ask) {
+  return names.map((name) => accessPluginVia(name, clientTransport(`client access plugin ${name}`, runId, ask)));
+}
+
+// src/site-access/resolve-site-access.use-case.ts
+import { resolveAccess } from "@opencraw/cli";
+async function resolveSiteAccess(params, runId, ask, env = process.env) {
+  const file = params.accessConfig ?? env.OPENCRAW_ACCESS;
+  if (file === void 0 && params.access !== void 0) throw new Error(`access profile "${params.access}" needs an access config: give "accessConfig", or set OPENCRAW_ACCESS where the driver runs`);
+  const access = await resolveAccess({ insecureTls: false, access: file, accessProfile: params.access });
+  return { access, accessPlugins: clientAccessPlugins(params.accessPlugins ?? [], runId, ask) };
+}
+
+// src/work-bridge/client-work-source.client.ts
+import { once } from "node:events";
+function clientWorkSource(runId, ask, notify) {
+  const kept = [];
+  let ended = false;
+  const askClient = async () => {
+    const { item } = workNextResultSchema.parse(await ask("work.next", { runId }));
+    if (item === null) {
+      ended = true;
+      return void 0;
+    }
+    return item;
+  };
+  const keepLate = async (answer) => {
+    try {
+      const item = await answer;
+      if (item !== void 0) kept.push(item);
+    } catch {
+    }
+  };
+  return {
+    next: async (options) => {
+      const waiting = kept.shift();
+      if (waiting !== void 0) return waiting;
+      if (ended) return;
+      const answer = askClient();
+      const signal = options?.signal;
+      if (signal === void 0) return await answer;
+      signal.throwIfAborted();
+      const settled = new AbortController();
+      const answered = (async () => {
+        const item = await answer;
+        return { item };
+      })();
+      const retired = (async () => {
+        try {
+          await once(signal, "abort", { signal: settled.signal });
+          return "retired";
+        } catch {
+          return "answered";
+        }
+      })();
+      try {
+        const first = await Promise.race([answered, retired]);
+        if (first !== "retired" && first !== "answered") return first.item;
+        void keepLate(answer);
+        throw signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason));
+      } finally {
+        settled.abort();
+      }
+    },
+    done: (item, report, records) => {
+      notify("work.done", { runId, item, report, records: records.map((record) => ({ key: record.key, data: record.data })) });
+    },
+    failed: (item, report, outcome) => {
+      notify("work.failed", { runId, item, report, outcome });
+    }
+  };
 }
 
 // src/session/recipe-loading.use-case.ts
@@ -155,36 +347,53 @@ function streamingSink() {
 function runSessions(notify, ask) {
   const running = /* @__PURE__ */ new Map();
   let next = 1;
-  const crawl = async (runId, crawler, set) => {
-    try {
-      const report = await crawler.run(set);
-      notify("finished", { runId, report });
-    } catch (error) {
-      notify("finished", { runId, error: error instanceof Error ? error.message : String(error) });
-    } finally {
-      running.delete(runId);
-      await crawler.close();
-    }
+  const crawlerFor = async (runId, params) => {
+    const { access, accessPlugins } = await resolveSiteAccess(params, runId, ask);
+    return createCrawler({
+      sink: params.out === void 0 ? streamingSink() : fileSink2(params.out, { append: params.append, browser: { executablePath: params.browser?.executablePath } }),
+      hooks: clientHooks(params.hooks ?? [], runId, ask),
+      captchaSolvers: clientCaptchaSolvers(params.captchaSolvers ?? [], runId, ask),
+      access,
+      accessPlugins,
+      profilesDir: process.env.OPENCRAW_PROFILES,
+      parallel: params.parallel,
+      resume: params.resume,
+      debug: params.dryRun,
+      browser: { headless: params.browser?.headless ?? true, executablePath: params.browser?.executablePath, ignoreHTTPSErrors: params.browser?.ignoreHTTPSErrors },
+      onEvent: (event) => {
+        notify("event", { runId, event });
+        if (event.type === "record:emit" && params.out === void 0) notify("record", { runId, recipeId: event.recipeId, key: event.key, data: event.data });
+      }
+    });
+  };
+  const track = (runId, crawler, crawling) => {
+    running.set(runId, crawler);
+    void (async () => {
+      try {
+        notify("finished", { runId, report: await crawling() });
+      } catch (error) {
+        notify("finished", { runId, error: error instanceof Error ? error.message : String(error) });
+      } finally {
+        running.delete(runId);
+        await crawler.close();
+      }
+    })();
   };
   return {
     start: async (params) => {
       const loaded = await loadRecipes(params);
       const set = params.dryRun === true ? new RecipeSet(loaded.output, loaded.inputs.map((input) => ({ ...input, limits: { ...input.limits, maxRecords: 1 } }))) : loaded;
       const runId = `run-${next++}`;
-      const crawler = createCrawler({
-        sink: params.out === void 0 ? streamingSink() : fileSink(params.out, { append: params.append, browser: { executablePath: params.browser?.executablePath } }),
-        hooks: clientHooks(params.hooks ?? [], runId, ask),
-        parallel: params.parallel,
-        resume: params.resume,
-        debug: params.dryRun,
-        browser: { headless: params.browser?.headless ?? true, executablePath: params.browser?.executablePath, ignoreHTTPSErrors: params.browser?.ignoreHTTPSErrors },
-        onEvent: (event) => {
-          notify("event", { runId, event });
-          if (event.type === "record:emit" && params.out === void 0) notify("record", { runId, recipeId: event.recipeId, key: event.key, data: event.data });
-        }
-      });
-      running.set(runId, crawler);
-      void crawl(runId, crawler, set);
+      const crawler = await crawlerFor(runId, params);
+      track(runId, crawler, async () => await crawler.run(set));
+      return runId;
+    },
+    startWork: async (params) => {
+      const set = await loadRecipes(params);
+      const runId = `run-${next++}`;
+      const crawler = await crawlerFor(runId, params);
+      const windows = params.windows;
+      track(runId, crawler, async () => await crawler.work(set, clientWorkSource(runId, ask, notify), { windows }));
       return runId;
     },
     cancel: async (runId) => {
@@ -204,6 +413,21 @@ function runSessions(notify, ask) {
   };
 }
 
+// src/site-probe/probe-site.use-case.ts
+import { probeUrl } from "@opencraw/cli";
+async function probeSite(params, probeId, ask) {
+  const { access, accessPlugins } = await resolveSiteAccess(params, probeId, ask);
+  const result = await probeUrl(params.url, {
+    browser: params.browser ?? false,
+    browserPath: params.browserPath ?? process.env.OPENCRAW_CHROMIUM,
+    insecureTls: params.insecureTls ?? false,
+    userAgent: params.userAgent,
+    accessConfig: access,
+    accessPlugins
+  });
+  return { ...result };
+}
+
 // src/transport/line-channel.client.ts
 import { createInterface } from "node:readline";
 
@@ -310,7 +534,7 @@ function openLineChannel(input, output, handle) {
 }
 
 // src/server/serve-driver.use-case.ts
-var METHODS = ["initialize", "validate", "run", "cancel", "shutdown"];
+var METHODS = ["initialize", "validate", "run", "work", "cancel", "probe", "diff", "export", "shutdown"];
 var major = (version) => version.split(".", 1)[0];
 function parsed(schema, params) {
   const result = schema.safeParse(params ?? {});
@@ -320,6 +544,7 @@ function parsed(schema, params) {
 async function serveDriver(input, output, identity) {
   let initialized = false;
   const stopping = new AbortController();
+  let probes = 0;
   const channel = openLineChannel(input, output, async (method, params) => {
     if (method === "initialize") {
       const hello = parsed(initializeParamsSchema, params);
@@ -332,7 +557,11 @@ async function serveDriver(input, output, identity) {
     if (!initialized) throw new RpcFailure(RPC_ERRORS.server, "call initialize first");
     if (method === "validate") return await validateRecipes(parsed(validateParamsSchema, params));
     if (method === "run") return { runId: await sessions.start(parsed(runParamsSchema, params)) };
+    if (method === "work") return { runId: await sessions.startWork(parsed(workParamsSchema, params)) };
     if (method === "cancel") return { cancelled: await sessions.cancel(parsed(cancelParamsSchema, params).runId) };
+    if (method === "probe") return await probeSite(parsed(probeParamsSchema, params), `probe-${++probes}`, channel.request);
+    if (method === "diff") return await diffRecordFiles(parsed(diffParamsSchema, params));
+    if (method === "export") return await exportRecordFiles(parsed(exportParamsSchema, params));
     await sessions.closeAll();
     setImmediate(() => {
       stopping.abort();
@@ -340,7 +569,7 @@ async function serveDriver(input, output, identity) {
     return {};
   });
   const sessions = runSessions(channel.notify, channel.request);
-  await Promise.race([channel.closed, once(stopping.signal, "abort")]);
+  await Promise.race([channel.closed, once2(stopping.signal, "abort")]);
   await channel.drained();
   await sessions.closeAll();
 }
@@ -353,13 +582,25 @@ export {
   calloutResultSchema,
   cancelParamsSchema,
   cancelResultSchema,
+  clientAccessPlugins,
+  clientCaptchaSolvers,
   clientHooks,
+  clientWorkSource,
+  diffParamsSchema,
+  diffRecordFiles,
+  diffResultSchema,
   driverProtocolJsonSchema,
   eventParamsSchema,
+  exportParamsSchema,
+  exportRecordFiles,
+  exportResultSchema,
   finishedParamsSchema,
   initializeParamsSchema,
   initializeResultSchema,
   openLineChannel,
+  probeParamsSchema,
+  probeResultSchema,
+  probeSite,
   recordParamsSchema,
   runParamsSchema,
   runResultSchema,
@@ -368,6 +609,12 @@ export {
   streamingSink,
   validateParamsSchema,
   validateRecipes,
-  validateResultSchema
+  validateResultSchema,
+  workDoneParamsSchema,
+  workFailedParamsSchema,
+  workItemSchema,
+  workNextParamsSchema,
+  workNextResultSchema,
+  workParamsSchema
 };
 //# sourceMappingURL=index.esm.js.map