@opencraw/driver 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,24 @@
+import type { AskClient } from '../callout-bridge/index.js';
+import type { RunParams } from '../protocol/index.js';
+/** Sends a notification to the client. */
+export type NotifyClient = (method: string, params: unknown) => void;
+/** 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>;
+    cancel: (runId: string) => Promise<boolean>;
+    closeAll: () => Promise<void>;
+}
+/**
+ * Starts and tracks runs. `start` loads and binds the recipes (a bad recipe fails the `run` request
+ * itself, with its problems), answers with a run id at once, and crawls 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. `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.
+ * @returns The sessions.
+ */
+export declare function runSessions(notify: NotifyClient, ask: AskClient): RunSessions;
+//# sourceMappingURL=run-session.use-case.d.ts.map

package/dist/src/session/streaming-sink.repository.d.ts

@@ -0,0 +1,8 @@
+import type { RecordSink } from '@opencraw/core';
+/**
+ * The sink of a run with no `out` file: it keeps nothing, since each record already reached the client
+ * as a `record` notification from its `record:emit` event, and only counts them for the report. A long
+ * crawl therefore streams in constant memory.
+ */
+export declare function streamingSink(): RecordSink;
+//# sourceMappingURL=streaming-sink.repository.d.ts.map

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

@@ -0,0 +1,5 @@
+export { openLineChannel } from './line-channel.client.js';
+export type { LineChannel, RequestHandler } from './line-channel.client.js';
+export { RPC_ERRORS, RpcFailure } from './json-rpc.contract.js';
+export type { RpcError, RpcMessage } from './json-rpc.contract.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/transport/json-rpc.contract.d.ts

@@ -0,0 +1,31 @@
+/** JSON-RPC 2.0 error codes the driver answers with. */
+export declare const RPC_ERRORS: {
+    readonly parse: -32700;
+    readonly invalidRequest: -32600;
+    readonly methodNotFound: -32601;
+    readonly invalidParams: -32602;
+    readonly internal: -32603;
+    /** A failure the caller must act on: the message says what to do. */
+    readonly server: -32000;
+};
+export interface RpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/** A request (it has an id and wants a response) or a notification (no id). */
+export interface RpcMessage {
+    jsonrpc: '2.0';
+    id?: number | string | null;
+    method?: string;
+    params?: unknown;
+    result?: unknown;
+    error?: RpcError;
+}
+/** An error a method handler throws to answer with a code other than `server`. */
+export declare class RpcFailure extends Error {
+    readonly code: number;
+    readonly data: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+//# sourceMappingURL=json-rpc.contract.d.ts.map

package/dist/src/transport/line-channel.client.d.ts

@@ -0,0 +1,27 @@
+import type { Readable, Writable } from 'node:stream';
+/** Answers a request: its result, or a thrown error (an `RpcFailure` for a specific code). */
+export type RequestHandler = (method: string, params: unknown) => Promise<unknown>;
+/** JSON-RPC 2.0 both ways over a stream pair, one message per line. */
+export interface LineChannel {
+    /** Sends a request to the other side and waits for its result; rejects with its error. */
+    request: (method: string, params: unknown) => Promise<unknown>;
+    /** Sends a notification: no answer is expected. */
+    notify: (method: string, params: unknown) => void;
+    /** Settles when the input ends (the other side closed it, or went away). */
+    closed: Promise<void>;
+    /** Settles once every request read so far has been answered: what to wait for before stopping. */
+    drained: () => Promise<void>;
+}
+/**
+ * Opens a channel: every line read from `input` is a JSON-RPC message. A request goes to `handle` and its
+ * answer is written back; a response settles the matching `request`. A line that is not JSON gets a parse
+ * error, a message without `jsonrpc: "2.0"` an invalid-request error, and nothing it does stops the channel.
+ * Writes are one line each, never interleaved.
+ *
+ * @param input - Where messages arrive (the driver's stdin).
+ * @param output - Where they go (the driver's stdout).
+ * @param handle - What answers the other side's requests and notifications.
+ * @returns The channel.
+ */
+export declare function openLineChannel(input: Readable, output: Writable, handle: RequestHandler): LineChannel;
+//# sourceMappingURL=line-channel.client.d.ts.map

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@opencraw/driver",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "OpenCraw's driver: the engine over JSON-RPC on stdio, for clients in other languages",
+  "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"
+    }
+  },
+  "bin": {
+    "opencraw-driver": "./dist/main.esm.js"
+  },
+  "files": [
+    "dist",
+    "schemas",
+    "!**/*.tsbuildinfo",
+    "!**/*.d.ts.map",
+    "!**/*.js.map"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "esbuild src/index.ts src/main.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",
+    "schemas": "node tools/emit-protocol-schema.mjs"
+  },
+  "dependencies": {
+    "@opencraw/cli": "^0.1.55",
+    "@opencraw/core": "^0.2.0",
+    "zod": "^4.6.5"
+  }
+}