@opencraw/driver 0.7.10 → 0.7.11

package/dist/src/protocol/driver-message.contract.d.ts

@@ -1,492 +0,0 @@
-import { z } from 'zod';
-/**
- * The driver protocol's version, separate from the package's: a client pins a major and the driver refuses
- * another. Additions (methods, optional fields) raise the minor; anything a client could break on, the major.
- */
-export declare const PROTOCOL_VERSION = "1.2.0";
-export declare const initializeParamsSchema: z.ZodObject<{
-    clientName: z.ZodString;
-    clientVersion: z.ZodString;
-    protocolVersion: z.ZodString;
-}, z.core.$strict>;
-export type InitializeParams = z.infer<typeof initializeParamsSchema>;
-export declare const initializeResultSchema: z.ZodObject<{
-    driverVersion: z.ZodString;
-    protocolVersion: z.ZodString;
-    methods: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type InitializeResult = z.infer<typeof initializeResultSchema>;
-export declare const validateParamsSchema: z.ZodObject<{
-    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    recipes: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    only: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export type ValidateParams = z.infer<typeof validateParamsSchema>;
-export declare const validateResultSchema: z.ZodObject<{
-    ok: z.ZodBoolean;
-    inputs: z.ZodArray<z.ZodString>;
-    hooks: z.ZodArray<z.ZodString>;
-    issues: z.ZodArray<z.ZodObject<{
-        source: z.ZodOptional<z.ZodString>;
-        recipeId: z.ZodOptional<z.ZodString>;
-        path: z.ZodString;
-        message: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ValidateResult = z.infer<typeof validateResultSchema>;
-export declare const runParamsSchema: z.ZodObject<{
-    accessConfig: z.ZodOptional<z.ZodString>;
-    access: z.ZodOptional<z.ZodString>;
-    accessPlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    recipes: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    only: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    out: z.ZodOptional<z.ZodString>;
-    append: z.ZodOptional<z.ZodBoolean>;
-    resume: z.ZodOptional<z.ZodBoolean>;
-    dryRun: z.ZodOptional<z.ZodBoolean>;
-    parallel: z.ZodOptional<z.ZodNumber>;
-    browser: z.ZodOptional<z.ZodObject<{
-        headless: z.ZodOptional<z.ZodBoolean>;
-        executablePath: z.ZodOptional<z.ZodString>;
-        ignoreHTTPSErrors: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>;
-    hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    captchaSolvers: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export type RunParams = z.infer<typeof runParamsSchema>;
-export declare const runResultSchema: z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strict>;
-export declare const workParamsSchema: z.ZodObject<{
-    accessConfig: z.ZodOptional<z.ZodString>;
-    access: z.ZodOptional<z.ZodString>;
-    accessPlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    recipes: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    only: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    out: z.ZodOptional<z.ZodString>;
-    append: z.ZodOptional<z.ZodBoolean>;
-    browser: z.ZodOptional<z.ZodObject<{
-        headless: z.ZodOptional<z.ZodBoolean>;
-        executablePath: z.ZodOptional<z.ZodString>;
-        ignoreHTTPSErrors: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>;
-    hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    captchaSolvers: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    windows: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-}, z.core.$strict>;
-export type WorkParams = z.infer<typeof workParamsSchema>;
-export declare const workItemSchema: z.ZodObject<{
-    id: z.ZodString;
-    vars: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-    recipe: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type WorkItemMessage = z.infer<typeof workItemSchema>;
-export type RunResult = z.infer<typeof runResultSchema>;
-export declare const cancelParamsSchema: z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strict>;
-export type CancelParams = z.infer<typeof cancelParamsSchema>;
-export declare const cancelResultSchema: z.ZodObject<{
-    cancelled: z.ZodBoolean;
-}, z.core.$strict>;
-export type CancelResult = z.infer<typeof cancelResultSchema>;
-export declare const probeParamsSchema: z.ZodObject<{
-    accessConfig: z.ZodOptional<z.ZodString>;
-    access: z.ZodOptional<z.ZodString>;
-    accessPlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    url: z.ZodString;
-    browser: z.ZodOptional<z.ZodBoolean>;
-    browserPath: z.ZodOptional<z.ZodString>;
-    insecureTls: z.ZodOptional<z.ZodBoolean>;
-    userAgent: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type ProbeParams = z.infer<typeof probeParamsSchema>;
-/** What the page holds and how a recipe could reach it (`ProbeResult`); its shape is the probe's, versioned with it. */
-export declare const probeResultSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-export declare const diffParamsSchema: z.ZodObject<{
-    previous: z.ZodString;
-    current: z.ZodString;
-    key: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    limit: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-export type DiffParams = z.infer<typeof diffParamsSchema>;
-export declare const diffResultSchema: z.ZodObject<{
-    added: z.ZodNumber;
-    removed: z.ZodNumber;
-    changed: z.ZodNumber;
-    unchanged: z.ZodNumber;
-    shrunk: z.ZodOptional<z.ZodObject<{
-        previous: z.ZodNumber;
-        current: z.ZodNumber;
-    }, z.core.$strict>>;
-    summary: z.ZodArray<z.ZodString>;
-    changes: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-export type DiffResult = z.infer<typeof diffResultSchema>;
-export declare const exportParamsSchema: z.ZodObject<{
-    records: z.ZodString;
-    output: z.ZodString;
-    out: z.ZodString;
-}, z.core.$strict>;
-export type ExportParams = z.infer<typeof exportParamsSchema>;
-export declare const exportResultSchema: z.ZodObject<{
-    written: z.ZodNumber;
-    location: z.ZodString;
-}, z.core.$strict>;
-export type ExportResult = z.infer<typeof exportResultSchema>;
-export declare const shutdownResultSchema: z.ZodObject<{}, z.core.$strict>;
-/** A window wants its next item. The client may hold the answer until it has one; `null` ends the work. */
-export declare const workNextParamsSchema: z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strict>;
-export declare const workNextResultSchema: z.ZodObject<{
-    item: z.ZodNullable<z.ZodObject<{
-        id: z.ZodString;
-        vars: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-        recipe: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type WorkNextResult = z.infer<typeof workNextResultSchema>;
-/** An item succeeded: its report (`RecipeReport`) and its records. */
-export declare const workDoneParamsSchema: z.ZodObject<{
-    runId: z.ZodString;
-    item: z.ZodObject<{
-        id: z.ZodString;
-        vars: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-        recipe: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    report: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    records: z.ZodArray<z.ZodObject<{
-        key: z.ZodNullable<z.ZodString>;
-        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type WorkDoneParams = z.infer<typeof workDoneParamsSchema>;
-/** An item failed (`failure`) or came out neither way (`neutral`, such as a captcha it could not pass). */
-export declare const workFailedParamsSchema: z.ZodObject<{
-    runId: z.ZodString;
-    item: z.ZodObject<{
-        id: z.ZodString;
-        vars: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-        recipe: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    report: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    outcome: z.ZodEnum<{
-        failure: "failure";
-        neutral: "neutral";
-    }>;
-}, z.core.$strict>;
-export type WorkFailedParams = z.infer<typeof workFailedParamsSchema>;
-/** Every crawl event, as core reports it (`CrawlEvent`); its shape is core's, versioned with core. */
-export declare const eventParamsSchema: z.ZodObject<{
-    runId: z.ZodString;
-    event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strict>;
-export type EventParams = z.infer<typeof eventParamsSchema>;
-export declare const recordParamsSchema: z.ZodObject<{
-    runId: z.ZodString;
-    recipeId: z.ZodString;
-    key: z.ZodNullable<z.ZodString>;
-    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strict>;
-export type RecordParams = z.infer<typeof recordParamsSchema>;
-export declare const finishedParamsSchema: z.ZodObject<{
-    runId: z.ZodString;
-    report: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    error: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type FinishedParams = z.infer<typeof finishedParamsSchema>;
-/** A hook, captcha solver or access plugin the client serves (`request.kind`): core's own callout request, answered with core's callout response. */
-export declare const calloutParamsSchema: z.ZodObject<{
-    runId: z.ZodString;
-    request: z.ZodObject<{
-        kind: z.ZodEnum<{
-            access: "access";
-            captcha: "captcha";
-            hook: "hook";
-        }>;
-        name: z.ZodString;
-        input: z.ZodOptional<z.ZodUnknown>;
-        args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        context: z.ZodObject<{
-            recipeId: z.ZodString;
-            scope: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        }, z.core.$strict>;
-        idempotencyKey: z.ZodString;
-        callback: z.ZodOptional<z.ZodObject<{
-            url: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type CalloutParams = z.infer<typeof calloutParamsSchema>;
-export declare const calloutResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    status: z.ZodLiteral<"ok">;
-    output: z.ZodOptional<z.ZodUnknown>;
-}, z.core.$strict>, z.ZodObject<{
-    status: z.ZodLiteral<"error">;
-    error: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    status: z.ZodLiteral<"pending">;
-    retryAfterMs: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>], "status">;
-/** Every method and notification, by name: what the generated schema and the clients' models are made from. */
-export declare const MESSAGES: {
-    readonly initialize: {
-        readonly direction: 'client-to-driver';
-        readonly params: z.ZodObject<{
-            clientName: z.ZodString;
-            clientVersion: z.ZodString;
-            protocolVersion: z.ZodString;
-        }, z.core.$strict>;
-        readonly result: z.ZodObject<{
-            driverVersion: z.ZodString;
-            protocolVersion: z.ZodString;
-            methods: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>;
-    };
-    readonly validate: {
-        readonly direction: 'client-to-driver';
-        readonly params: z.ZodObject<{
-            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            recipes: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-            only: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-        readonly result: z.ZodObject<{
-            ok: z.ZodBoolean;
-            inputs: z.ZodArray<z.ZodString>;
-            hooks: z.ZodArray<z.ZodString>;
-            issues: z.ZodArray<z.ZodObject<{
-                source: z.ZodOptional<z.ZodString>;
-                recipeId: z.ZodOptional<z.ZodString>;
-                path: z.ZodString;
-                message: z.ZodString;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-    };
-    readonly run: {
-        readonly direction: 'client-to-driver';
-        readonly params: z.ZodObject<{
-            accessConfig: z.ZodOptional<z.ZodString>;
-            access: z.ZodOptional<z.ZodString>;
-            accessPlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            recipes: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-            only: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            out: z.ZodOptional<z.ZodString>;
-            append: z.ZodOptional<z.ZodBoolean>;
-            resume: z.ZodOptional<z.ZodBoolean>;
-            dryRun: z.ZodOptional<z.ZodBoolean>;
-            parallel: z.ZodOptional<z.ZodNumber>;
-            browser: z.ZodOptional<z.ZodObject<{
-                headless: z.ZodOptional<z.ZodBoolean>;
-                executablePath: z.ZodOptional<z.ZodString>;
-                ignoreHTTPSErrors: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strict>>;
-            hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            captchaSolvers: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-        readonly result: z.ZodObject<{
-            runId: z.ZodString;
-        }, z.core.$strict>;
-    };
-    readonly work: {
-        readonly direction: 'client-to-driver';
-        readonly params: z.ZodObject<{
-            accessConfig: z.ZodOptional<z.ZodString>;
-            access: z.ZodOptional<z.ZodString>;
-            accessPlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            recipes: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-            only: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            out: z.ZodOptional<z.ZodString>;
-            append: z.ZodOptional<z.ZodBoolean>;
-            browser: z.ZodOptional<z.ZodObject<{
-                headless: z.ZodOptional<z.ZodBoolean>;
-                executablePath: z.ZodOptional<z.ZodString>;
-                ignoreHTTPSErrors: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strict>>;
-            hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            captchaSolvers: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            windows: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-        }, z.core.$strict>;
-        readonly result: z.ZodObject<{
-            runId: z.ZodString;
-        }, z.core.$strict>;
-    };
-    readonly cancel: {
-        readonly direction: 'client-to-driver';
-        readonly params: z.ZodObject<{
-            runId: z.ZodString;
-        }, z.core.$strict>;
-        readonly result: z.ZodObject<{
-            cancelled: z.ZodBoolean;
-        }, z.core.$strict>;
-    };
-    readonly probe: {
-        readonly direction: 'client-to-driver';
-        readonly params: z.ZodObject<{
-            accessConfig: z.ZodOptional<z.ZodString>;
-            access: z.ZodOptional<z.ZodString>;
-            accessPlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            url: z.ZodString;
-            browser: z.ZodOptional<z.ZodBoolean>;
-            browserPath: z.ZodOptional<z.ZodString>;
-            insecureTls: z.ZodOptional<z.ZodBoolean>;
-            userAgent: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-        readonly result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    };
-    readonly diff: {
-        readonly direction: 'client-to-driver';
-        readonly params: z.ZodObject<{
-            previous: z.ZodString;
-            current: z.ZodString;
-            key: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            limit: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>;
-        readonly result: z.ZodObject<{
-            added: z.ZodNumber;
-            removed: z.ZodNumber;
-            changed: z.ZodNumber;
-            unchanged: z.ZodNumber;
-            shrunk: z.ZodOptional<z.ZodObject<{
-                previous: z.ZodNumber;
-                current: z.ZodNumber;
-            }, z.core.$strict>>;
-            summary: z.ZodArray<z.ZodString>;
-            changes: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            truncated: z.ZodBoolean;
-        }, z.core.$strict>;
-    };
-    readonly export: {
-        readonly direction: 'client-to-driver';
-        readonly params: z.ZodObject<{
-            records: z.ZodString;
-            output: z.ZodString;
-            out: z.ZodString;
-        }, z.core.$strict>;
-        readonly result: z.ZodObject<{
-            written: z.ZodNumber;
-            location: z.ZodString;
-        }, z.core.$strict>;
-    };
-    readonly shutdown: {
-        readonly direction: 'client-to-driver';
-        readonly params: undefined;
-        readonly result: z.ZodObject<{}, z.core.$strict>;
-    };
-    readonly callout: {
-        readonly direction: 'driver-to-client';
-        readonly params: z.ZodObject<{
-            runId: z.ZodString;
-            request: z.ZodObject<{
-                kind: z.ZodEnum<{
-                    access: "access";
-                    captcha: "captcha";
-                    hook: "hook";
-                }>;
-                name: z.ZodString;
-                input: z.ZodOptional<z.ZodUnknown>;
-                args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                context: z.ZodObject<{
-                    recipeId: z.ZodString;
-                    scope: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                }, z.core.$strict>;
-                idempotencyKey: z.ZodString;
-                callback: z.ZodOptional<z.ZodObject<{
-                    url: z.ZodString;
-                }, z.core.$strict>>;
-            }, z.core.$strict>;
-        }, z.core.$strict>;
-        readonly result: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            status: z.ZodLiteral<"ok">;
-            output: z.ZodOptional<z.ZodUnknown>;
-        }, z.core.$strict>, z.ZodObject<{
-            status: z.ZodLiteral<"error">;
-            error: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            status: z.ZodLiteral<"pending">;
-            retryAfterMs: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>], "status">;
-    };
-    readonly 'work.next': {
-        readonly direction: 'driver-to-client';
-        readonly params: z.ZodObject<{
-            runId: z.ZodString;
-        }, z.core.$strict>;
-        readonly result: z.ZodObject<{
-            item: z.ZodNullable<z.ZodObject<{
-                id: z.ZodString;
-                vars: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-                recipe: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-    };
-    readonly 'work.done': {
-        readonly direction: 'driver-to-client';
-        readonly params: z.ZodObject<{
-            runId: z.ZodString;
-            item: z.ZodObject<{
-                id: z.ZodString;
-                vars: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-                recipe: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>;
-            report: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            records: z.ZodArray<z.ZodObject<{
-                key: z.ZodNullable<z.ZodString>;
-                data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        readonly result: undefined;
-    };
-    readonly 'work.failed': {
-        readonly direction: 'driver-to-client';
-        readonly params: z.ZodObject<{
-            runId: z.ZodString;
-            item: z.ZodObject<{
-                id: z.ZodString;
-                vars: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-                recipe: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>;
-            report: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            outcome: z.ZodEnum<{
-                failure: "failure";
-                neutral: "neutral";
-            }>;
-        }, z.core.$strict>;
-        readonly result: undefined;
-    };
-    readonly event: {
-        readonly direction: 'driver-to-client';
-        readonly params: z.ZodObject<{
-            runId: z.ZodString;
-            event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        }, z.core.$strict>;
-        readonly result: undefined;
-    };
-    readonly record: {
-        readonly direction: 'driver-to-client';
-        readonly params: z.ZodObject<{
-            runId: z.ZodString;
-            recipeId: z.ZodString;
-            key: z.ZodNullable<z.ZodString>;
-            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        }, z.core.$strict>;
-        readonly result: undefined;
-    };
-    readonly finished: {
-        readonly direction: 'driver-to-client';
-        readonly params: z.ZodObject<{
-            runId: z.ZodString;
-            report: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            error: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-        readonly result: undefined;
-    };
-};
-//# sourceMappingURL=driver-message.contract.d.ts.map

package/dist/src/protocol/index.d.ts

@@ -1,4 +0,0 @@
-export { PROTOCOL_VERSION, MESSAGES, initializeParamsSchema, initializeResultSchema, validateParamsSchema, validateResultSchema, runParamsSchema, runResultSchema, cancelParamsSchema, cancelResultSchema, shutdownResultSchema, eventParamsSchema, recordParamsSchema, finishedParamsSchema, calloutParamsSchema, calloutResultSchema, probeParamsSchema, probeResultSchema, diffParamsSchema, diffResultSchema, exportParamsSchema, exportResultSchema, workParamsSchema, workItemSchema, workNextParamsSchema, workNextResultSchema, workDoneParamsSchema, workFailedParamsSchema, } from './driver-message.contract.js';
-export type { InitializeParams, InitializeResult, ValidateParams, ValidateResult, RunParams, RunResult, CancelParams, CancelResult, EventParams, RecordParams, FinishedParams, CalloutParams, ProbeParams, DiffParams, DiffResult, ExportParams, ExportResult, WorkParams, WorkItemMessage, WorkNextResult, WorkDoneParams, WorkFailedParams, } from './driver-message.contract.js';
-export { driverProtocolJsonSchema } from './driver-json-schema.mapper.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/record-files/diff-record-files.use-case.d.ts

@@ -1,10 +0,0 @@
-import type { DiffParams, DiffResult } from '../protocol/index.js';
-/**
- * Compares two runs' JSON Lines files by key: how many records were added, removed, changed and left
- * alone, the report a person reads, and the changes themselves, up to `limit`.
- *
- * @param params - The two files, the key fields, the fields to ignore and the limit.
- * @returns The comparison.
- */
-export declare function diffRecordFiles(params: DiffParams): Promise<DiffResult>;
-//# sourceMappingURL=diff-record-files.use-case.d.ts.map

package/dist/src/record-files/export-record-files.use-case.d.ts

@@ -1,11 +0,0 @@
-import type { ExportParams, ExportResult } from '../protocol/index.js';
-/**
- * Writes a finished run's JSON Lines file again in another format, the extension of `out` naming it, as
- * the CLI's `export` does. The output recipe gives the columns: its fields, in order, with their types.
- *
- * @param params - The records, the output recipe and the file to write.
- * @returns How many records were written, and where.
- * @throws RecipeValidationError When `output` is not an output recipe.
- */
-export declare function exportRecordFiles(params: ExportParams): Promise<ExportResult>;
-//# sourceMappingURL=export-record-files.use-case.d.ts.map

package/dist/src/record-files/index.d.ts

@@ -1,3 +0,0 @@
-export { diffRecordFiles } from './diff-record-files.use-case.js';
-export { exportRecordFiles } from './export-record-files.use-case.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,4 +0,0 @@
-export { RUNTIME_PLATFORMS, runtimeManifestSchema } from './runtime-manifest.contract.js';
-export type { RuntimeManifest, RuntimePlatform } from './runtime-manifest.contract.js';
-export { runtimeManifestJsonSchema } from './runtime-manifest-json-schema.mapper.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/runtime-manifest/runtime-manifest-json-schema.mapper.d.ts

@@ -1,8 +0,0 @@
-/**
- * `driver-runtime.json`'s JSON Schema, written to `schemas/driver-runtime.schema.json`: what clients in
- * other languages generate their manifest model from.
- *
- * @returns The schema.
- */
-export declare function runtimeManifestJsonSchema(): Record<string, unknown>;
-//# sourceMappingURL=runtime-manifest-json-schema.mapper.d.ts.map

package/dist/src/runtime-manifest/runtime-manifest.contract.d.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-/** The platforms the driver's runtime is built for: `<process.platform>-<process.arch>`. */
-export declare const RUNTIME_PLATFORMS: readonly ['win32-x64', 'darwin-arm64', 'darwin-x64', 'linux-x64', 'linux-arm64'];
-export type RuntimePlatform = typeof RUNTIME_PLATFORMS[number];
-/**
- * `driver-runtime.json`, an asset of each driver release beside the archives: what a client in any
- * language reads to download the runtime for its platform, check it and start it. The archive holds a
- * Node binary, the driver and its dependencies, and `runtime.json` (`command`: the Node binary and the
- * driver's entry, both relative to the folder the archive is unpacked into).
- */
-export declare const runtimeManifestSchema: z.ZodObject<{
-    driverVersion: z.ZodString;
-    protocolVersion: z.ZodString;
-    node: z.ZodString;
-    archives: z.ZodRecord<z.ZodEnum<{
-        "darwin-arm64": "darwin-arm64";
-        "darwin-x64": "darwin-x64";
-        "linux-arm64": "linux-arm64";
-        "linux-x64": "linux-x64";
-        "win32-x64": "win32-x64";
-    }> & z.core.$partial, z.ZodObject<{
-        file: z.ZodString;
-        sha256: z.ZodString;
-        size: z.ZodNumber;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type RuntimeManifest = z.infer<typeof runtimeManifestSchema>;
-//# sourceMappingURL=runtime-manifest.contract.d.ts.map

package/dist/src/server/index.d.ts

@@ -1,3 +0,0 @@
-export { serveDriver } from './serve-driver.use-case.js';
-export type { DriverIdentity } from './serve-driver.use-case.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/server/serve-driver.use-case.d.ts

@@ -1,17 +0,0 @@
-import type { Readable, Writable } from 'node:stream';
-/** What the driver says about itself in `initialize`. */
-export interface DriverIdentity {
-    driverVersion: string;
-}
-/**
- * Serves the driver protocol on a stream pair until the client closes its end or asks for `shutdown`.
- * Every method but `initialize` is refused until the client has initialized with a protocol of the same
- * major. On close, every run still going is closed.
- *
- * @param input - Where the client's messages arrive (stdin).
- * @param output - Where the driver's go (stdout). Nothing else may write to it.
- * @param identity - The driver's version, for `initialize`.
- * @returns Settles once the driver has stopped.
- */
-export declare function serveDriver(input: Readable, output: Writable, identity: DriverIdentity): Promise<void>;
-//# sourceMappingURL=serve-driver.use-case.d.ts.map

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

@@ -1,5 +0,0 @@
-export { runSessions } from './run-session.use-case.js';
-export type { LocalPlugins, RunSessions } from './run-session.use-case.js';
-export { validateRecipes, hooksOf, loadRecipes, sourceOf } from './recipe-loading.use-case.js';
-export { streamingSink } from './streaming-sink.repository.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/session/recipe-loading.use-case.d.ts

@@ -1,23 +0,0 @@
-import type { RecipeSet, RecipeSource } from '@opencraw/core';
-import type { ValidateParams, ValidateResult } from '../protocol/index.js';
-/** The recipes a method names: files and folders, or the recipes themselves. Exactly one of the two. */
-export declare function sourceOf(params: {
-    paths?: string[];
-    recipes?: Record<string, unknown>[];
-}): RecipeSource;
-/** Loads and binds a method's recipes, keeping the input ids in `only`. */
-export declare function loadRecipes(params: {
-    paths?: string[];
-    recipes?: Record<string, unknown>[];
-    only?: string[];
-}): Promise<RecipeSet>;
-/** Every hook the set's input recipes call, once each, sorted. */
-export declare function hooksOf(set: RecipeSet): string[];
-/**
- * Checks recipes the way `run` would load them, without running them.
- *
- * @param params - The recipes and the input ids to keep.
- * @returns Whether they load, the inputs and hooks a run would have, and every problem with its path.
- */
-export declare function validateRecipes(params: ValidateParams): Promise<ValidateResult>;
-//# sourceMappingURL=recipe-loading.use-case.d.ts.map

package/dist/src/session/run-session.use-case.d.ts

@@ -1,35 +0,0 @@
-import { RecipeSet } from '@opencraw/core';
-import type { AccessPlugin, CaptchaSolver, HookMap } from '@opencraw/core';
-import type { AskClient, NotifyClient } from '../callout-bridge/index.js';
-import type { RunParams, WorkParams } from '../protocol/index.js';
-/** The runs a driver has going, by id, so `cancel` can reach them and `shutdown` close them all. */
-export interface RunSessions {
-    start: (params: RunParams) => Promise<string>;
-    /** As `start`, for recipes the host has already loaded and bound (`params`' recipe source is ignored). */
-    startLoaded: (set: RecipeSet, params: Omit<RunParams, 'paths' | 'recipes'>) => Promise<string>;
-    startWork: (params: WorkParams) => Promise<string>;
-    cancel: (runId: string) => Promise<boolean>;
-    closeAll: () => Promise<void>;
-}
-/** What the host serves itself, in process, besides what the client serves: an MCP server's plugins module. */
-export interface LocalPlugins {
-    hooks?: HookMap;
-    captchaSolvers?: CaptchaSolver[];
-    accessPlugins?: AccessPlugin[];
-}
-/**
- * Starts and tracks runs and worker pools. `start` and `startWork` load and bind the recipes (a bad
- * recipe fails the request itself, with its problems), answer with a run id at once, and crawl in the
- * background: every crawl event goes to the client as an `event` notification, every record as a
- * `record` one unless `out` names a file, and the end as `finished` with the report. A hook the client
- * serves is asked back with a `callout` request, and so are the captcha solvers and access plugins it
- * serves; a worker pool asks the client for its items (`work.next`). `cancel` closes the run's crawler,
- * which stops its recipes; the run still ends with `finished`.
- *
- * @param notify - The channel's notify.
- * @param ask - The channel's request, for callouts and work.
- * @param local - Hooks, captcha solvers and access plugins the host serves itself, beside the client's.
- * @returns The sessions.
- */
-export declare function runSessions(notify: NotifyClient, ask: AskClient, local?: LocalPlugins): RunSessions;
-//# sourceMappingURL=run-session.use-case.d.ts.map