@opencraw/cli 0.1.53 → 0.1.55

package/dist/index.esm.js

@@ -1,13 +1,6 @@
-import { parseArgs } from 'node:util';
-import { writeFile, readFile } from 'node:fs/promises';
-import { readableKey, readRecordsFile, diffRecords, fileSink, parseOutputRecipe, outputRecordOf, RecipeValidationError, loadAccessConfig, HostAllowlist, AccessBroker, HttpClient, parseXml, BrowserClient, readRecipeSource, parseInputRecipe, bindRecipeSet, memorySink, createCrawler, RecipeSet, variantLabel, diffOptionsFor, RecipeBindingError, traceLine } from '@opencraw/core';
-import { resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { describePdf, findData, describeWorkbook, describeDeck, describeJson, describeXml, describeHtml } from '@opencraw/probe';
-export { findData } from '@opencraw/probe';
-import { readFileSync } from 'node:fs';
-
-const USAGE = `opencraw <command> [options]
+// src/arguments/parse-arguments.algorithm.ts
+import { parseArgs } from "node:util";
+var USAGE = `opencraw <command> [options]
 
 Commands
   validate <recipe files or directories...>   Parse and bind the recipes; list every problem with its path.
@@ -65,437 +58,235 @@ Options for both
                       (for session.captcha and captcha steps); --hooks, or OPENCRAW_PLUGINS /
                       OPENCRAW_HOOKS. It runs as your code: trust it.
   --help, --version`;
-const OPTIONS = {
-  'out': {
-    type: 'string'
-  },
-  'append': {
-    type: 'boolean'
-  },
-  'resume': {
-    type: 'boolean'
-  },
-  'only': {
-    type: 'string',
-    multiple: true
-  },
-  'dry-run': {
-    type: 'boolean'
-  },
-  'trace': {
-    type: 'boolean'
-  },
-  'headed': {
-    type: 'boolean'
-  },
-  'profiles': {
-    type: 'string'
-  },
-  'retries': {
-    type: 'string'
-  },
-  'parallel': {
-    type: 'string'
-  },
-  'diff': {
-    type: 'string'
-  },
-  'changes': {
-    type: 'string'
-  },
-  'key': {
-    type: 'string'
-  },
-  'ignore': {
-    type: 'string'
-  },
-  'host-delay': {
-    type: 'string'
-  },
-  'host-concurrency': {
-    type: 'string'
-  },
-  'hooks': {
-    type: 'string'
-  },
-  'open': {
-    type: 'string'
-  },
-  'plugins': {
-    type: 'string'
-  },
-  'browser': {
-    type: 'boolean'
-  },
-  'browser-path': {
-    type: 'string'
-  },
-  'insecure-tls': {
-    type: 'boolean'
-  },
-  'user-agent': {
-    type: 'string'
-  },
-  'access': {
-    type: 'string'
-  },
-  'access-profile': {
-    type: 'string'
-  },
-  'help': {
-    type: 'boolean',
-    short: 'h'
-  },
-  'version': {
-    type: 'boolean',
-    short: 'v'
-  }
+var OPTIONS = {
+  "out": { type: "string" },
+  "append": { type: "boolean" },
+  "resume": { type: "boolean" },
+  "only": { type: "string", multiple: true },
+  "dry-run": { type: "boolean" },
+  "trace": { type: "boolean" },
+  "headed": { type: "boolean" },
+  "profiles": { type: "string" },
+  "retries": { type: "string" },
+  "parallel": { type: "string" },
+  "diff": { type: "string" },
+  "changes": { type: "string" },
+  "key": { type: "string" },
+  "ignore": { type: "string" },
+  "host-delay": { type: "string" },
+  "host-concurrency": { type: "string" },
+  "hooks": { type: "string" },
+  "open": { type: "string" },
+  "plugins": { type: "string" },
+  "browser": { type: "boolean" },
+  "browser-path": { type: "string" },
+  "insecure-tls": { type: "boolean" },
+  "user-agent": { type: "string" },
+  "access": { type: "string" },
+  "access-profile": { type: "string" },
+  "help": { type: "boolean", short: "h" },
+  "version": { type: "boolean", short: "v" }
 };
-/**
- * Turns argv into a command.
- *
- * @param argv - The arguments after the program name.
- * @param env - The environment, for the defaults some options have.
- * @returns The command.
- * @throws Error with a usage message on bad input.
- */
 function parseArguments(argv, env = {}) {
-  const {
-    values,
-    positionals
-  } = parseArgs({
-    args: [...argv],
-    options: OPTIONS,
-    allowPositionals: true,
-    strict: true
-  });
-  if (values.help === true) return {
-    name: 'help'
-  };
-  if (values.version === true) return {
-    name: 'version'
-  };
+  const { values, positionals } = parseArgs({ args: [...argv], options: OPTIONS, allowPositionals: true, strict: true });
+  if (values.help === true) return { name: "help" };
+  if (values.version === true) return { name: "version" };
   const [name, ...rest] = positionals;
   const options = {
-    browserPath: values['browser-path'] ?? env.OPENCRAW_CHROMIUM,
-    insecureTls: values['insecure-tls'] === true || env.OPENCRAW_INSECURE_TLS === '1',
-    userAgent: values['user-agent'],
-    access: values.access ?? (env.OPENCRAW_ACCESS === '' ? undefined : env.OPENCRAW_ACCESS),
-    accessProfile: values['access-profile'],
+    browserPath: values["browser-path"] ?? env.OPENCRAW_CHROMIUM,
+    insecureTls: values["insecure-tls"] === true || env.OPENCRAW_INSECURE_TLS === "1",
+    userAgent: values["user-agent"],
+    access: values.access ?? (env.OPENCRAW_ACCESS === "" ? void 0 : env.OPENCRAW_ACCESS),
+    accessProfile: values["access-profile"],
     plugins: values.plugins ?? values.hooks ?? nonEmpty(env.OPENCRAW_PLUGINS) ?? nonEmpty(env.OPENCRAW_HOOKS)
   };
   switch (name) {
-    case undefined:
-      {
-        return {
-          name: 'help'
-        };
-      }
-    case 'validate':
-      {
-        if (rest.length === 0) throw new Error('validate needs at least one recipe file or directory');
-        return {
-          name: 'validate',
-          paths: rest
-        };
-      }
-    case 'export':
-      {
-        if (rest.length !== 2) throw new Error('export needs the records file (JSON Lines) and the output recipe');
-        if (values.out === undefined) throw new Error('export needs --out <file>: its extension is the format');
-        return {
-          name: 'export',
-          records: rest[0],
-          output: rest[1],
-          out: values.out,
-          options
-        };
-      }
-    case 'diff':
-      {
-        if (rest.length !== 2) throw new Error('diff needs two JSON Lines files: the previous run, then the current one');
-        return {
-          name: 'diff',
-          previous: rest[0],
-          current: rest[1],
-          key: list(values.key),
-          ignore: list(values.ignore),
-          changes: values.changes
-        };
-      }
-    case 'run':
-      {
-        if (rest.length === 0) throw new Error('run needs at least one recipe file or directory');
-        if (values.diff !== undefined && values.resume === true) throw new Error('--diff compares the records a run emits, and --resume skips some: use one or the other');
-        if (values.changes !== undefined && values.diff === undefined) throw new Error('--changes needs --diff (or the diff command)');
-        if (values.resume === true && values.append !== true) throw new Error('--resume needs --append (and --out)');
-        if ((values.append === true || values.resume === true) && values.out === undefined) throw new Error('--append and --resume need --out');
-        return {
-          name: 'run',
-          paths: rest,
-          out: values.out,
-          append: values.append === true,
-          resume: values.resume === true,
-          trace: values.trace === true,
-          dryRun: values['dry-run'] === true,
-          only: values.only ?? [],
-          headed: values.headed === true,
-          profiles: values.profiles ?? nonEmpty(env.OPENCRAW_PROFILES),
-          retries: integer(values.retries, '--retries', 1),
-          parallel: integer(values.parallel, '--parallel', 1),
-          diff: values.diff,
-          changes: values.changes,
-          throttle: {
-            delayMs: integer(values['host-delay'], '--host-delay', 0),
-            concurrency: integer(values['host-concurrency'], '--host-concurrency', 1)
-          },
-          options
-        };
-      }
-    case 'probe':
-      {
-        if (rest.length !== 1) throw new Error('probe needs exactly one URL');
-        return {
-          name: 'probe',
-          url: rest[0],
-          browser: values.browser === true,
-          options
-        };
-      }
-    case 'studio':
-      {
-        if (rest.length > 1) throw new Error('studio takes at most one folder');
-        return {
-          name: 'studio',
-          folder: rest[0],
-          plugins: options.plugins,
-          open: values.open
-        };
-      }
-    default:
-      {
-        throw new Error(`unknown command "${name}"`);
-      }
+    case void 0: {
+      return { name: "help" };
+    }
+    case "validate": {
+      if (rest.length === 0) throw new Error("validate needs at least one recipe file or directory");
+      return { name: "validate", paths: rest };
+    }
+    case "export": {
+      if (rest.length !== 2) throw new Error("export needs the records file (JSON Lines) and the output recipe");
+      if (values.out === void 0) throw new Error("export needs --out <file>: its extension is the format");
+      return { name: "export", records: rest[0], output: rest[1], out: values.out, options };
+    }
+    case "diff": {
+      if (rest.length !== 2) throw new Error("diff needs two JSON Lines files: the previous run, then the current one");
+      return { name: "diff", previous: rest[0], current: rest[1], key: list(values.key), ignore: list(values.ignore), changes: values.changes };
+    }
+    case "run": {
+      if (rest.length === 0) throw new Error("run needs at least one recipe file or directory");
+      if (values.diff !== void 0 && values.resume === true) throw new Error("--diff compares the records a run emits, and --resume skips some: use one or the other");
+      if (values.changes !== void 0 && values.diff === void 0) throw new Error("--changes needs --diff (or the diff command)");
+      if (values.resume === true && values.append !== true) throw new Error("--resume needs --append (and --out)");
+      if ((values.append === true || values.resume === true) && values.out === void 0) throw new Error("--append and --resume need --out");
+      return { name: "run", paths: rest, out: values.out, append: values.append === true, resume: values.resume === true, trace: values.trace === true, dryRun: values["dry-run"] === true, only: values.only ?? [], headed: values.headed === true, profiles: values.profiles ?? nonEmpty(env.OPENCRAW_PROFILES), retries: integer(values.retries, "--retries", 1), parallel: integer(values.parallel, "--parallel", 1), diff: values.diff, changes: values.changes, throttle: { delayMs: integer(values["host-delay"], "--host-delay", 0), concurrency: integer(values["host-concurrency"], "--host-concurrency", 1) }, options };
+    }
+    case "probe": {
+      if (rest.length !== 1) throw new Error("probe needs exactly one URL");
+      return { name: "probe", url: rest[0], browser: values.browser === true, options };
+    }
+    case "studio": {
+      if (rest.length > 1) throw new Error("studio takes at most one folder");
+      return { name: "studio", folder: rest[0], plugins: options.plugins, open: values.open };
+    }
+    default: {
+      throw new Error(`unknown command "${name}"`);
+    }
   }
 }
 function integer(value, name, minimum) {
-  if (value === undefined) return undefined;
+  if (value === void 0) return void 0;
   const number = Number(value);
   if (!Number.isSafeInteger(number) || number < minimum) throw new Error(`${name} needs a whole number of at least ${minimum}, not "${value}"`);
   return number;
 }
 function list(value) {
-  return value === undefined ? [] : value.split(',').map(entry => entry.trim()).filter(entry => entry !== '');
+  return value === void 0 ? [] : value.split(",").map((entry) => entry.trim()).filter((entry) => entry !== "");
 }
 function nonEmpty(value) {
-  return value === '' ? undefined : value;
+  return value === "" ? void 0 : value;
 }
 
-/** Changes listed one by one, at most; the rest are counted. */
-const LIST_LIMIT = 50;
-/** A value longer than this is cut in the report. */
-const VALUE_CHARS = 60;
-/**
- * A diff as people read it: the counts, a warning when the run lost most of
- * its records, then one line per change, `-` removed, `~` changed (with each
- * field's before → after), `+` added.
- *
- * @param diff - The diff.
- * @param limit - Changes listed at most.
- * @returns The lines.
- */
+// src/diff/diff-files.use-case.ts
+import { writeFile } from "node:fs/promises";
+import { diffRecords, readRecordsFile } from "@opencraw/core";
+
+// src/diff/diff-report.mapper.ts
+import { readableKey } from "@opencraw/core";
+var LIST_LIMIT = 50;
+var VALUE_CHARS = 60;
 function diffReport(diff, limit = LIST_LIMIT) {
   const lines = [`${diff.added} added, ${diff.removed} removed, ${diff.changed} changed, ${diff.unchanged} unchanged (${diff.counts.previous} records before, ${diff.counts.current} now)`];
-  if (diff.shrunk !== undefined) lines.push(`! ${diff.shrunk.current} records where the previous run had ${diff.shrunk.previous}: if the source did not shrink, the site may have changed and the recipe no longer finds everything`);
+  if (diff.shrunk !== void 0) lines.push(`! ${diff.shrunk.current} records where the previous run had ${diff.shrunk.previous}: if the source did not shrink, the site may have changed and the recipe no longer finds everything`);
   if (diff.repeated > 0) lines.push(`! ${diff.repeated} records repeat a key already seen and were not compared: is the key complete?`);
   for (const change of diff.changes.slice(0, limit)) {
     const key = readableKey(change.key);
-    if (change.change === 'added') lines.push(`+ ${key}`);else if (change.change === 'removed') lines.push(`- ${key}`);else lines.push(`~ ${key}  ${change.fields.map(field => fieldLine(field)).join('; ')}`);
+    if (change.change === "added") lines.push(`+ ${key}`);
+    else if (change.change === "removed") lines.push(`- ${key}`);
+    else lines.push(`~ ${key}  ${change.fields.map((field) => fieldLine(field)).join("; ")}`);
   }
-  if (diff.changes.length > limit) lines.push(`… and ${diff.changes.length - limit} more`);
+  if (diff.changes.length > limit) lines.push(`\u2026 and ${diff.changes.length - limit} more`);
   return lines;
 }
 function fieldLine(change) {
-  return `${change.field}: ${shown(change.before)} → ${shown(change.after)}`;
+  return `${change.field}: ${shown(change.before)} \u2192 ${shown(change.after)}`;
 }
 function shown(value) {
-  const text = JSON.stringify(value) ?? 'null';
-  return text.length > VALUE_CHARS ? `${text.slice(0, VALUE_CHARS)}…` : text;
+  const text = JSON.stringify(value) ?? "null";
+  return text.length > VALUE_CHARS ? `${text.slice(0, VALUE_CHARS)}\u2026` : text;
 }
 
-/**
- * Compares two runs' JSON Lines files and prints what changed; with
- * `--changes`, writes every change as a JSON line too.
- *
- * @param command - The parsed `diff` command.
- * @param terminal - Where the report goes.
- * @returns The exit code: 0, or 1 when a file cannot be read or has no key.
- */
+// src/diff/diff-files.use-case.ts
 async function diffFiles(command, terminal) {
   try {
     const [previous, current] = await Promise.all([readRecordsFile(command.previous), readRecordsFile(command.current)]);
-    const diff = diffRecords(previous, current, {
-      key: command.key.length === 0 ? undefined : command.key,
-      ignore: command.ignore
-    });
+    const diff = diffRecords(previous, current, { key: command.key.length === 0 ? void 0 : command.key, ignore: command.ignore });
     for (const line of diffReport(diff)) terminal.out(line);
-    if (command.changes !== undefined) await writeChanges(command.changes, diff);
+    if (command.changes !== void 0) await writeChanges(command.changes, diff);
     return 0;
   } catch (error) {
     terminal.err(error instanceof Error ? error.message : String(error));
     return 1;
   }
 }
-/**
- * Writes a diff's changes as JSON Lines: `{ change, key, before?, after?, fields? }`.
- *
- * @param path - The file.
- * @param diff - The diff.
- */
 async function writeChanges(path, diff) {
-  await writeFile(path, diff.changes.map(change => `${JSON.stringify(change)}\n`).join(''));
+  await writeFile(path, diff.changes.map((change) => `${JSON.stringify(change)}
+`).join(""));
 }
 
-/**
- * Writes a finished run's JSON Lines file again in another format: the extension of `--out` chooses it, as it does for `run`. The output recipe
- * supplies the columns (its fields, in order, with their types and descriptions).
- *
- * @param command - The parsed `export` command.
- * @param terminal - Where the result and errors go.
- * @returns The exit code: 0, or 1 when a file cannot be read, the recipe is not an output recipe, or the extension names no format.
- */
+// src/export/export-records.use-case.ts
+import { readFile } from "node:fs/promises";
+import { RecipeValidationError, fileSink, outputRecordOf, parseOutputRecipe, readRecordsFile as readRecordsFile2 } from "@opencraw/core";
 async function exportRecords(command, terminal) {
   try {
-    const sink = fileSink(command.out, {
-      browser: {
-        executablePath: command.options.browserPath
-      }
-    });
-    const output = parseOutputRecipe(JSON.parse(await readFile(command.output, 'utf8')), command.output);
-    const stored = await readRecordsFile(command.records);
+    const sink = fileSink(command.out, { browser: { executablePath: command.options.browserPath } });
+    const output = parseOutputRecipe(JSON.parse(await readFile(command.output, "utf8")), command.output);
+    const stored = await readRecordsFile2(command.records);
     await sink.open(output);
     for (const line of stored) await sink.write(outputRecordOf(line));
     const summary = await sink.close();
     terminal.err(`${String(summary.written)} records written to ${summary.location ?? command.out}`);
     return 0;
   } catch (error) {
-    if (error instanceof RecipeValidationError) for (const issue of error.issues) terminal.err(`${error.source}: ${issue.path === '' ? '(root)' : issue.path}: ${issue.message}`);else terminal.err(error instanceof Error ? error.message : String(error));
+    if (error instanceof RecipeValidationError) for (const issue of error.issues) terminal.err(`${error.source}: ${issue.path === "" ? "(root)" : issue.path}: ${issue.message}`);
+    else terminal.err(error instanceof Error ? error.message : String(error));
     return 1;
   }
 }
 
-/**
- * The access config a command runs with: the file `--access` (or
- * `OPENCRAW_ACCESS`) names, with `--access-profile` as its default.
- *
- * @param options - The command's shared options.
- * @returns The config, or `undefined` for direct access.
- * @throws Error when a profile is asked for without a config, or is not in it.
- */
+// src/probe/probe-page.use-case.ts
+import { resolve as resolve2 } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { AccessBroker, BrowserClient, HostAllowlist, HttpClient, parseXml } from "@opencraw/core";
+import { describeDeck, describeHtml, describeJson, describePdf, describeWorkbook, describeXml, findData } from "@opencraw/probe";
+
+// src/access/resolve-access.use-case.ts
+import { loadAccessConfig } from "@opencraw/core";
 async function resolveAccess(options) {
-  if (options.access === undefined) {
-    if (options.accessProfile !== undefined) throw new Error('--access-profile needs an access config: --access <file> or OPENCRAW_ACCESS');
-    return undefined;
+  if (options.access === void 0) {
+    if (options.accessProfile !== void 0) throw new Error("--access-profile needs an access config: --access <file> or OPENCRAW_ACCESS");
+    return void 0;
   }
   const config = await loadAccessConfig(options.access);
-  if (options.accessProfile === undefined) return config;
+  if (options.accessProfile === void 0) return config;
   if (!Object.hasOwn(config.profiles, options.accessProfile)) {
-    throw new Error(`access profile "${options.accessProfile}" is not in ${options.access} (profiles: ${Object.keys(config.profiles).join(', ') || 'none'})`);
+    throw new Error(`access profile "${options.accessProfile}" is not in ${options.access} (profiles: ${Object.keys(config.profiles).join(", ") || "none"})`);
   }
-  return {
-    ...config,
-    default: options.accessProfile
-  };
+  return { ...config, default: options.accessProfile };
 }
 
-/** The named exports that mark a module as a plugins module rather than a bare hooks module. */
-const PLUGIN_EXPORTS = ['hooks', 'accessPlugins', 'captchaSolvers'];
-/**
- * Loads a plugins module: a JavaScript module whose named exports `hooks`
- * (`{ name: function }`), `accessPlugins` (`[{ name, lease }]`) and
- * `captchaSolvers` (`[{ name, solve }]`) give what recipes and access profiles
- * refer to by name:
- *
- * ```js
- * export const hooks = { positive: v => v > 0 }
- * export const accessPlugins = [{ name: 'browserbase', lease: async () => ({ cdp: { endpoint } }) }]
- * export const captchaSolvers = [{ name: 'capsolver', solve: async (challenge, { page }) => ({ status: 'solved' }) }]
- * ```
- *
- * A module with none of those names is a bare hooks module, as before: its
- * default export when that is an object of functions, else its named function
- * exports.
- *
- * The module runs with the caller's privileges, like any code the caller
- * imports: point this only at a file you trust.
- *
- * @param path - A `.mjs` / `.js` / `.cjs` file, or a `.ts` / `.mts` file on a Node that strips types (22.18+).
- * @param importModule - How to import it; `import()` unless a test says otherwise.
- * @returns The hooks and plugins.
- * @throws Error naming the file when it cannot be imported, provides nothing,
- * or provides something that is not what its name promises.
- */
+// src/hooks-module/load-hooks.repository.ts
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+var PLUGIN_EXPORTS = ["hooks", "accessPlugins", "captchaSolvers"];
 async function loadPlugins(path, importModule = importByUrl) {
   const url = pathToFileURL(resolve(path)).href;
   let exported;
   try {
     exported = await importModule(url);
   } catch (error) {
-    throw new Error(`${path}: cannot load hooks (${error.message})`, {
-      cause: error
-    });
+    throw new Error(`${path}: cannot load hooks (${error.message})`, { cause: error });
   }
-  if (PLUGIN_EXPORTS.every(name => !Object.hasOwn(exported, name))) {
+  if (PLUGIN_EXPORTS.every((name) => !Object.hasOwn(exported, name))) {
     const hooks = hooksOf(hookExports(exported), path);
     if (Object.keys(hooks).length === 0) throw new Error(`${path}: exports no hooks (export default { name: function } or named functions) and no plugins (export const hooks, accessPlugins, captchaSolvers)`);
-    return {
-      hooks,
-      accessPlugins: [],
-      captchaSolvers: []
-    };
+    return { hooks, accessPlugins: [], captchaSolvers: [] };
   }
   return {
-    hooks: hooksOf(objectExport(exported.hooks, 'hooks', path), path),
-    accessPlugins: pluginsOf(exported.accessPlugins, 'accessPlugins', 'lease', path),
-    captchaSolvers: pluginsOf(exported.captchaSolvers, 'captchaSolvers', 'solve', path)
+    hooks: hooksOf(objectExport(exported.hooks, "hooks", path), path),
+    accessPlugins: pluginsOf(exported.accessPlugins, "accessPlugins", "lease", path),
+    captchaSolvers: pluginsOf(exported.captchaSolvers, "captchaSolvers", "solve", path)
   };
 }
-/**
- * Loads the hooks of a hooks or plugins module (see {@link loadPlugins}).
- *
- * @param path - A `.mjs` / `.js` / `.cjs` file.
- * @param importModule - How to import it.
- * @returns The hooks by name.
- * @throws Error naming the file when it cannot be imported or exports no hooks.
- */
 async function loadHooks(path, importModule = importByUrl) {
-  const {
-    hooks
-  } = await loadPlugins(path, importModule);
+  const { hooks } = await loadPlugins(path, importModule);
   if (Object.keys(hooks).length === 0) throw new Error(`${path}: exports no hooks (export default { name: function } or named functions)`);
   return hooks;
 }
 function hooksOf(candidates, path) {
   const hooks = {};
   for (const [name, value] of Object.entries(candidates)) {
-    if (typeof value !== 'function') throw new Error(`${path}: hook "${name}" is ${value === null ? 'null' : typeof value}, not a function`);
+    if (typeof value !== "function") throw new Error(`${path}: hook "${name}" is ${value === null ? "null" : typeof value}, not a function`);
     hooks[name] = value;
   }
   return hooks;
 }
 function objectExport(value, name, path) {
-  if (value === undefined) return {};
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) throw new Error(`${path}: "${name}" must be an object of functions`);
+  if (value === void 0) return {};
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${path}: "${name}" must be an object of functions`);
   return value;
 }
-/** A list of `{ name, <method> }` plugins, checked. */
 function pluginsOf(value, exportName, method, path) {
-  if (value === undefined) return [];
+  if (value === void 0) return [];
   if (!Array.isArray(value)) throw new Error(`${path}: "${exportName}" must be an array of { name, ${method} }`);
-  const names = new Set();
+  const names = /* @__PURE__ */ new Set();
   for (const [index, plugin] of value.entries()) {
     const entry = plugin;
-    if (typeof entry?.name !== 'string' || entry.name === '' || typeof entry[method] !== 'function') throw new Error(`${path}: ${exportName}[${index}] must be { name: string, ${method}: function }`);
+    if (typeof entry?.name !== "string" || entry.name === "" || typeof entry[method] !== "function") throw new Error(`${path}: ${exportName}[${index}] must be { name: string, ${method}: function }`);
     if (names.has(entry.name)) throw new Error(`${path}: ${exportName} names "${entry.name}" twice`);
     names.add(entry.name);
   }
@@ -506,130 +297,99 @@ async function importByUrl(url) {
 }
 function hookExports(exported) {
   const fallback = exported.default;
-  if (typeof fallback === 'object' && fallback !== null && !Array.isArray(fallback)) return fallback;
-  const named = Object.entries(exported).filter(([name]) => name !== 'default' && name !== 'module.exports');
+  if (typeof fallback === "object" && fallback !== null && !Array.isArray(fallback)) return fallback;
+  const named = Object.entries(exported).filter(([name]) => name !== "default" && name !== "module.exports");
   return Object.fromEntries(named);
 }
 
-/**
- * Renders a probe's findings as text.
- *
- * @param url - The URL probed.
- * @param status - The HTTP status.
- * @param findings - What `findData` found.
- * @param observed - JSON responses a browser saw, when `--browser` was used.
- * @param html - The tables (and, for Markdown, the outline and front matter) found.
- * @returns The report.
- */
+// src/probe/probe-report.mapper.ts
 function probeReport(url, status, findings, observed = [], html) {
-  const sections = [section('Markdown front matter (in script[data-front-matter])', html?.frontMatter === undefined || html.frontMatter.length === 0 ? [] : [`  keys: ${html.frontMatter.join(', ')}`]), section('Sections (a "css" selector for each)', (html?.outline ?? []).map(entry => `  ${'  '.repeat(entry.level - 1)}${entry.selector}`)), section('HTML tables (a "table" extract selector for each)', (html?.tables ?? []).map(table => `  ${table.table}  ${table.selector}${table.hint === undefined ? '' : `  (${table.hint})`}\n        ${table.text}`)), section('JSON-LD blocks', findings.jsonLd.map(block => `  type=${block.types}, ${block.keys} keys`)), section('Inline JSON (candidates)', findings.inlineJson.map(block => `  ${block.where}, ${block.size} chars, keys: ${block.keys.slice(0, 8).join(', ')}`)), section('.json URLs referenced', findings.jsonUrls.map(url_ => `  ${url_}`)), section('Script hosts', findings.scriptHosts.map(host => `  ${host}`)), section('Links that look like an API', findings.apiLinks.map(link => `  ${link}`)), observed.length > 0 ? section('JSON responses observed in the browser', observed.map(entry => `  ${entry}`)) : ''];
-  return [`${url} (HTTP ${status})`, '', ...sections].filter(line => line !== '').join('\n');
+  const sections = [
+    section("Markdown front matter (in script[data-front-matter])", html?.frontMatter === void 0 || html.frontMatter.length === 0 ? [] : [`  keys: ${html.frontMatter.join(", ")}`]),
+    section('Sections (a "css" selector for each)', (html?.outline ?? []).map((entry) => `  ${"  ".repeat(entry.level - 1)}${entry.selector}`)),
+    section('HTML tables (a "table" extract selector for each)', (html?.tables ?? []).map((table) => `  ${table.table}  ${table.selector}${table.hint === void 0 ? "" : `  (${table.hint})`}
+        ${table.text}`)),
+    section("JSON-LD blocks", findings.jsonLd.map((block) => `  type=${block.types}, ${block.keys} keys`)),
+    section("Inline JSON (candidates)", findings.inlineJson.map((block) => `  ${block.where}, ${block.size} chars, keys: ${block.keys.slice(0, 8).join(", ")}`)),
+    section(".json URLs referenced", findings.jsonUrls.map((url_) => `  ${url_}`)),
+    section("Script hosts", findings.scriptHosts.map((host) => `  ${host}`)),
+    section("Links that look like an API", findings.apiLinks.map((link) => `  ${link}`)),
+    observed.length > 0 ? section("JSON responses observed in the browser", observed.map((entry) => `  ${entry}`)) : ""
+  ];
+  return [`${url} (HTTP ${status})`, "", ...sections].filter((line) => line !== "").join("\n");
 }
-/**
- * Renders what a probe found in a PDF as text.
- *
- * @param url - The URL or file probed.
- * @param pdf - What `describePdf` found.
- * @returns The report.
- */
 function pdfReport(url, pdf) {
-  return [`${url} (PDF, ${pdf.pages} page${pdf.pages === 1 ? '' : 's'})`, '', section('Likely table headers (a "table" extract selector for each)', pdf.headers.map(header => `  p${header.page}  ${header.selector}\n        ${header.text}`)), section('First rows (cells separated by " | ")', pdf.rows.map(row => `  p${row.page}  ${row.text}`))].filter(line => line !== '').join('\n');
+  return [
+    `${url} (PDF, ${pdf.pages} page${pdf.pages === 1 ? "" : "s"})`,
+    "",
+    section('Likely table headers (a "table" extract selector for each)', pdf.headers.map((header) => `  p${header.page}  ${header.selector}
+        ${header.text}`)),
+    section('First rows (cells separated by " | ")', pdf.rows.map((row) => `  p${row.page}  ${row.text}`))
+  ].filter((line) => line !== "").join("\n");
 }
-/**
- * Formats what a probe found in a workbook (a CSV or a spreadsheet): its sheets,
- * the rows that look like table headers with a selector for each, and the first
- * rows.
- *
- * @param url - The workbook's URL.
- * @param workbook - The findings.
- * @returns The report.
- */
 function workbookReport(url, workbook) {
-  const read = workbook.csv === undefined ? 'workbook' : `CSV, ${workbook.csv.encoding}, delimited by ${delimiterName(workbook.csv.delimiter)}`;
-  return [`${url} (${read})`, '', section('Sheets', workbook.sheets.map(sheet => `  ${sheet.name}${sheet.hidden ? ' (hidden)' : ''}: ${sheet.rows} rows × ${sheet.columns} columns`)), section('Likely table headers (a "table" extract selector for each)', workbook.headers.map(header => `  ${header.sheet} r${header.row}  ${header.selector}${header.hint === undefined ? '' : `  (${header.hint})`}\n        ${header.text}`)), section('First rows (cells separated by " | ")', workbook.rows.map(row => `  ${row.sheet} r${row.row}  ${row.text}`))].filter(line => line !== '').join('\n');
+  const read = workbook.csv === void 0 ? "workbook" : `CSV, ${workbook.csv.encoding}, delimited by ${delimiterName(workbook.csv.delimiter)}`;
+  return [
+    `${url} (${read})`,
+    "",
+    section("Sheets", workbook.sheets.map((sheet) => `  ${sheet.name}${sheet.hidden ? " (hidden)" : ""}: ${sheet.rows} rows \xD7 ${sheet.columns} columns`)),
+    section('Likely table headers (a "table" extract selector for each)', workbook.headers.map((header) => `  ${header.sheet} r${header.row}  ${header.selector}${header.hint === void 0 ? "" : `  (${header.hint})`}
+        ${header.text}`)),
+    section('First rows (cells separated by " | ")', workbook.rows.map((row) => `  ${row.sheet} r${row.row}  ${row.text}`))
+  ].filter((line) => line !== "").join("\n");
 }
-/**
- * Formats what a probe found in a deck (a presentation): its slides, the native
- * tables' headers with a selector for each, its charts, and the slides whose
- * text boxes look like a table.
- *
- * @param url - The deck's URL.
- * @param deck - The findings.
- * @returns The report.
- */
 function deckReport(url, deck) {
-  return [`${url} (presentation, ${deck.slides.length} slide${deck.slides.length === 1 ? '' : 's'}, ${deck.width} × ${deck.height} pt)`, '', section('Slides', deck.slides.map(slide => `  ${slide.number}  ${slide.title === '' ? '(no title)' : slide.title}${slide.hidden ? ' (hidden)' : ''}: ${slide.shapes} text boxes, ${slide.tables} tables, ${slide.charts} charts`)), section('Likely table headers (a "table" extract selector for each)', deck.headers.map(header => `  slide ${header.slide}  ${header.selector}${header.hint === undefined ? '' : `  (${header.hint})`}\n        ${header.text}`)), section('Text boxes laid out as a table (a "table" extract with "shapes": true)', deck.grids.map(grid => `  slide ${grid.slide}  ${grid.title}: ${grid.boxes} short boxes`)), section('Charts (read with jsonpath: $.slides[*].charts[*].series[*])', deck.charts.map(chart => `  slide ${chart.slide}  ${chart.type}${chart.title === undefined ? '' : ` "${chart.title}"`}: ${chart.series.map(series => `${series.name} (${series.points})`).join(', ')}`))].filter(line => line !== '').join('\n');
+  return [
+    `${url} (presentation, ${deck.slides.length} slide${deck.slides.length === 1 ? "" : "s"}, ${deck.width} \xD7 ${deck.height} pt)`,
+    "",
+    section("Slides", deck.slides.map((slide) => `  ${slide.number}  ${slide.title === "" ? "(no title)" : slide.title}${slide.hidden ? " (hidden)" : ""}: ${slide.shapes} text boxes, ${slide.tables} tables, ${slide.charts} charts`)),
+    section('Likely table headers (a "table" extract selector for each)', deck.headers.map((header) => `  slide ${header.slide}  ${header.selector}${header.hint === void 0 ? "" : `  (${header.hint})`}
+        ${header.text}`)),
+    section('Text boxes laid out as a table (a "table" extract with "shapes": true)', deck.grids.map((grid) => `  slide ${grid.slide}  ${grid.title}: ${grid.boxes} short boxes`)),
+    section("Charts (read with jsonpath: $.slides[*].charts[*].series[*])", deck.charts.map((chart) => `  slide ${chart.slide}  ${chart.type}${chart.title === void 0 ? "" : ` "${chart.title}"`}: ${chart.series.map((series) => `${series.name} (${series.points})`).join(", ")}`))
+  ].filter((line) => line !== "").join("\n");
 }
-/**
- * Formats what a probe found in JSON data: its record lists with the path a
- * `jsonpath` extract needs, then its structure.
- *
- * @param url - The document's URL.
- * @param json - The findings.
- * @returns The report.
- */
 function jsonReport(url, json) {
-  const read = {
-    json: 'JSON',
-    jsonl: 'JSON Lines',
-    yaml: 'YAML'
-  }[json.format] ?? json.format;
-  return [`${url} (${read}: ${json.type})`, '', section('Record lists (a "jsonpath" selector for each, largest first)', json.lists.map(list => `  ${list.path}  ${list.length} entries\n        keys: ${list.keys.join(', ')}`)), section('Structure', json.tree.map(line => `  ${line}`))].filter(line => line !== '').join('\n');
+  const read = { json: "JSON", jsonl: "JSON Lines", yaml: "YAML" }[json.format] ?? json.format;
+  return [
+    `${url} (${read}: ${json.type})`,
+    "",
+    section('Record lists (a "jsonpath" selector for each, largest first)', json.lists.map((list2) => `  ${list2.path}  ${list2.length} entries
+        keys: ${list2.keys.join(", ")}`)),
+    section("Structure", json.tree.map((line) => `  ${line}`))
+  ].filter((line) => line !== "").join("\n");
 }
-/**
- * Formats what a probe found in an XML document: its namespaces and the
- * `namespaces` an `xpath` extract needs, the elements that repeat, and its structure.
- *
- * @param url - The document's URL.
- * @param xml - The findings.
- * @returns The report.
- */
 function xmlReport(url, xml) {
-  const defaultNamespace = xml.namespaces[''];
-  const namespaceRows = Object.entries(xml.namespaces).map(([prefix, uri]) => `  ${prefix === '' ? '(default)' : prefix}  ${uri}`);
-  const hint = defaultNamespace === undefined ? [] : ['', `  The elements are in a default namespace: query with "namespaces": { "x": "${defaultNamespace}" } and //x:${xml.root},`, '  or with "ignoreNamespaces": true and plain names, as below.'];
-  return [`${url} (XML: ${xml.root}${xml.sitemap === undefined ? '' : `, a sitemap of ${xml.sitemap.locations} ${xml.sitemap.kind === 'urlset' ? 'pages' : 'sitemaps'}`})`, '', section('Namespaces', [...namespaceRows, ...hint]), section('Repeated elements (an "xpath" selector for each, largest first)', xml.lists.map(list => `  ${list.path}  ${list.count} entries${list.children.length > 0 ? `\n        children: ${list.children.join(', ')}` : ''}`)), section('Structure', xml.tree.map(line => `  ${line}`))].filter(line => line !== '').join('\n');
+  const defaultNamespace = xml.namespaces[""];
+  const namespaceRows = Object.entries(xml.namespaces).map(([prefix, uri]) => `  ${prefix === "" ? "(default)" : prefix}  ${uri}`);
+  const hint = defaultNamespace === void 0 ? [] : ["", `  The elements are in a default namespace: query with "namespaces": { "x": "${defaultNamespace}" } and //x:${xml.root},`, '  or with "ignoreNamespaces": true and plain names, as below.'];
+  return [
+    `${url} (XML: ${xml.root}${xml.sitemap === void 0 ? "" : `, a sitemap of ${xml.sitemap.locations} ${xml.sitemap.kind === "urlset" ? "pages" : "sitemaps"}`})`,
+    "",
+    section("Namespaces", [...namespaceRows, ...hint]),
+    section('Repeated elements (an "xpath" selector for each, largest first)', xml.lists.map((list2) => `  ${list2.path}  ${list2.count} entries${list2.children.length > 0 ? `
+        children: ${list2.children.join(", ")}` : ""}`)),
+    section("Structure", xml.tree.map((line) => `  ${line}`))
+  ].filter((line) => line !== "").join("\n");
 }
 function delimiterName(delimiter) {
-  const names = {
-    '\t': 'tabs',
-    ',': 'commas',
-    ';': 'semicolons',
-    '|': 'pipes'
-  };
+  const names = { "	": "tabs", ",": "commas", ";": "semicolons", "|": "pipes" };
   return names[delimiter] ?? `"${delimiter}"`;
 }
 function section(title, rows) {
-  if (rows.length === 0) return '';
-  return [`${title}:`, ...rows, ''].join('\n');
+  if (rows.length === 0) return "";
+  return [`${title}:`, ...rows, ""].join("\n");
 }
 
-const BROWSER_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0 Safari/537.36';
-const OBSERVE_MS = 4000;
-/**
- * Fetches a page and finds where its data lives, through the access profile the
- * options name (direct without one). With `browser: true` it also
- * renders the page and lists the JSON responses seen while it settles, which
- * finds endpoints a plain fetch of the initial HTML cannot. No `Terminal`
- * involved: the cli's `probePage` and `@opencraw/mcp`'s probe tool both
- * build on this, one printing the result, the other returning it as data.
- *
- * A PDF, a spreadsheet, a CSV or a presentation (by content type, or a local
- * path) is read instead: its rows, and the rows that look like table headers.
- *
- * @param url - The page to probe, or a local file path.
- * @param options - Browser path, TLS and user agent, plus whether to render.
- * @returns What was found.
- * @throws Error when the fetch itself fails.
- */
+// src/probe/probe-page.use-case.ts
+var BROWSER_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0 Safari/537.36";
+var OBSERVE_MS = 4e3;
 async function probeUrl(url, options) {
   const allowedHosts = HostAllowlist.of(options.allowedHosts);
-  const plugins = options.accessPlugins === undefined && options.plugins !== undefined ? await loadPlugins(options.plugins) : undefined;
-  const access = options.accessConfig === undefined ? await resolveAccess(options) : withDefault(options.accessConfig, options.accessProfile);
-  const lease = await new AccessBroker(access, options.accessPlugins ?? plugins?.accessPlugins).lease({
-    recipeId: 'probe'
-  });
-  if (lease.cdp !== undefined) throw new Error(`access profile "${lease.profile}" is a remote browser; probe fetches over HTTP and needs a proxy profile`);
+  const plugins = options.accessPlugins === void 0 && options.plugins !== void 0 ? await loadPlugins(options.plugins) : void 0;
+  const access = options.accessConfig === void 0 ? await resolveAccess(options) : withDefault(options.accessConfig, options.accessProfile);
+  const lease = await new AccessBroker(access, options.accessPlugins ?? plugins?.accessPlugins).lease({ recipeId: "probe" });
+  if (lease.cdp !== void 0) throw new Error(`access profile "${lease.profile}" is a remote browser; probe fetches over HTTP and needs a proxy profile`);
   const client = await HttpClient.open({
     userAgent: options.userAgent ?? BROWSER_USER_AGENT,
     ignoreHTTPSErrors: options.insecureTls || lease.ignoreHTTPSErrors === true,
@@ -638,77 +398,23 @@ async function probeUrl(url, options) {
     allowedHosts
   });
   try {
-    const target = /^[a-z][\w+.-]+:/i.test(url) ? url : pathToFileURL(resolve(url)).href;
-    // GitHub raw and CDNs serve Markdown as text/plain: a .md URL is read as Markdown.
+    const target = /^[a-z][\w+.-]+:/i.test(url) ? url : pathToFileURL2(resolve2(url)).href;
     const markdown = /\.(?:md|markdown)$/i.test(new URL(target).pathname);
-    const response = await client.send({
-      url: target,
-      ...(markdown && {
-        as: 'markdown'
-      })
-    });
-    const {
-      body
-    } = response;
-    if (body.kind === 'pdf') return {
-      url: response.url,
-      status: response.status,
-      findings: findData(''),
-      observed: [],
-      pdf: describePdf(body)
-    };
-    if (body.kind === 'workbook') return {
-      url: response.url,
-      status: response.status,
-      findings: findData(''),
-      observed: [],
-      workbook: describeWorkbook(body)
-    };
-    if (body.kind === 'deck') return {
-      url: response.url,
-      status: response.status,
-      findings: findData(''),
-      observed: [],
-      deck: describeDeck(body)
-    };
-    if (body.kind === 'json') return {
-      url: response.url,
-      status: response.status,
-      findings: findData(''),
-      observed: [],
-      json: describeJson(body.data, response.format ?? 'json')
-    };
-    if (body.kind === 'xml') return {
-      url: response.url,
-      status: response.status,
-      findings: findData(''),
-      observed: [],
-      xml: describeXml(parseXml(body.xml, response.url))
-    };
-    const text = body.kind === 'html' ? body.html : body.text;
-    const observed = options.browser && !target.startsWith('file:') ? await observeBrowserJson(url, options, lease, allowedHosts) : [];
-    const html = body.kind === 'html' ? {
-      html: describeHtml(body.html, response.format === 'markdown' || response.format === 'docx')
-    } : {};
-    return {
-      url: response.url,
-      status: response.status,
-      findings: findData(text),
-      observed,
-      ...html
-    };
+    const response = await client.send({ url: target, ...markdown && { as: "markdown" } });
+    const { body } = response;
+    if (body.kind === "pdf") return { url: response.url, status: response.status, findings: findData(""), observed: [], pdf: describePdf(body) };
+    if (body.kind === "workbook") return { url: response.url, status: response.status, findings: findData(""), observed: [], workbook: describeWorkbook(body) };
+    if (body.kind === "deck") return { url: response.url, status: response.status, findings: findData(""), observed: [], deck: describeDeck(body) };
+    if (body.kind === "json") return { url: response.url, status: response.status, findings: findData(""), observed: [], json: describeJson(body.data, response.format ?? "json") };
+    if (body.kind === "xml") return { url: response.url, status: response.status, findings: findData(""), observed: [], xml: describeXml(parseXml(body.xml, response.url)) };
+    const text = body.kind === "html" ? body.html : body.text;
+    const observed = options.browser && !target.startsWith("file:") ? await observeBrowserJson(url, options, lease, allowedHosts) : [];
+    const html = body.kind === "html" ? { html: describeHtml(body.html, response.format === "markdown" || response.format === "docx") } : {};
+    return { url: response.url, status: response.status, findings: findData(text), observed, ...html };
   } finally {
     await client.dispose();
   }
 }
-/**
- * Fetches a page and reports where its data lives, to a `Terminal`.
- *
- * @param url - The page to probe.
- * @param options - Browser path, TLS and user agent, plus whether to render.
- * @param terminal - Where the report goes.
- * @returns The exit code: 0, or 1 on a fetch failure.
- */
 async function probePage(url, options, terminal) {
   try {
     const result = await probeUrl(url, options);
@@ -720,28 +426,16 @@ async function probePage(url, options, terminal) {
   }
 }
 async function observeBrowserJson(url, options, lease, allowedHosts) {
-  const browser = await BrowserClient.launch({
-    executablePath: options.browserPath,
-    ignoreHTTPSErrors: options.insecureTls
-  });
+  const browser = await BrowserClient.launch({ executablePath: options.browserPath, ignoreHTTPSErrors: options.insecureTls });
   try {
-    const session = await browser.newSession({
-      userAgent: options.userAgent,
-      proxy: lease.proxy,
-      headers: lease.headers,
-      ignoreHTTPSErrors: lease.ignoreHTTPSErrors,
-      allowedHosts
-    });
+    const session = await browser.newSession({ userAgent: options.userAgent, proxy: lease.proxy, headers: lease.headers, ignoreHTTPSErrors: lease.ignoreHTTPSErrors, allowedHosts });
     const seen = [];
-    session.page.on('response', response => {
-      if ((response.headers()['content-type'] ?? '').includes('json')) seen.push(`${response.status()} ${response.url()}`);
+    session.page.on("response", (response) => {
+      if ((response.headers()["content-type"] ?? "").includes("json")) seen.push(`${response.status()} ${response.url()}`);
     });
     try {
-      await session.page.goto(url, {
-        waitUntil: 'networkidle'
-      });
+      await session.page.goto(url, { waitUntil: "networkidle" });
     } catch {
-      // a page that never idles (long-poll, websocket) still yields whatever the browser observed
     }
     await session.page.waitForTimeout(OBSERVE_MS);
     await session.close();
@@ -750,82 +444,56 @@ async function observeBrowserJson(url, options, lease, allowedHosts) {
     await browser.close();
   }
 }
-/** An access config with its default profile overridden, when one is named. */
 function withDefault(config, profile) {
-  if (profile === undefined) return config;
-  if (!Object.hasOwn(config.profiles, profile)) throw new Error(`access profile "${profile}" is not in the access config (profiles: ${Object.keys(config.profiles).join(', ') || 'none'})`);
-  return {
-    ...config,
-    default: profile
-  };
+  if (profile === void 0) return config;
+  if (!Object.hasOwn(config.profiles, profile)) throw new Error(`access profile "${profile}" is not in the access config (profiles: ${Object.keys(config.profiles).join(", ") || "none"})`);
+  return { ...config, default: profile };
 }
 function reportOf(result) {
-  if (result.pdf !== undefined) return pdfReport(result.url, result.pdf);
-  if (result.workbook !== undefined) return workbookReport(result.url, result.workbook);
-  if (result.deck !== undefined) return deckReport(result.url, result.deck);
-  if (result.json !== undefined) return jsonReport(result.url, result.json);
-  if (result.xml !== undefined) return xmlReport(result.url, result.xml);
+  if (result.pdf !== void 0) return pdfReport(result.url, result.pdf);
+  if (result.workbook !== void 0) return workbookReport(result.url, result.workbook);
+  if (result.deck !== void 0) return deckReport(result.url, result.deck);
+  if (result.json !== void 0) return jsonReport(result.url, result.json);
+  if (result.xml !== void 0) return xmlReport(result.url, result.xml);
   return probeReport(result.url, result.status, result.findings, result.observed, result.html);
 }
 
-/**
- * Reads recipes, expanding directories to their `.json` and `.jsonl` files
- * (sorted, not recursive), and sorts them by `kind`. The command line passes
- * paths; the MCP server also passes recipes it was handed inline.
- *
- * @param sources - Files or directories, or any other recipe source core reads.
- * @returns The decoded recipes.
- * @throws Error naming a file that is not JSON or JSON Lines.
- */
+// src/probe/index.ts
+import { findData as findData2 } from "@opencraw/probe";
+
+// src/main.ts
+import { readFileSync } from "node:fs";
+
+// src/run/run-recipes.use-case.ts
+import { RecipeBindingError, RecipeSet, RecipeValidationError as RecipeValidationError2, createCrawler, diffOptionsFor, diffRecords as diffRecords2, fileSink as fileSink2, memorySink, readRecordsFile as readRecordsFile3, traceLine, variantLabel } from "@opencraw/core";
+
+// src/run/load-for-run.use-case.ts
+import { bindRecipeSet, parseInputRecipe, parseOutputRecipe as parseOutputRecipe2 } from "@opencraw/core";
+
+// src/recipe-files/read-recipe-files.repository.ts
+import { readRecipeSource } from "@opencraw/core";
 async function readRecipeFiles(sources) {
-  const result = {
-    outputs: [],
-    inputs: [],
-    others: []
-  };
+  const result = { outputs: [], inputs: [], others: [] };
   const documents = await readRecipeSource(sources);
   for (const document of documents) {
     const kind = document.content?.kind;
-    if (kind === 'output') result.outputs.push({
-      path: document.source,
-      recipe: document.content
-    });else if (kind === 'input') result.inputs.push({
-      path: document.source,
-      recipe: document.content
-    });else result.others.push(document.source);
+    if (kind === "output") result.outputs.push({ path: document.source, recipe: document.content });
+    else if (kind === "input") result.inputs.push({ path: document.source, recipe: document.content });
+    else result.others.push(document.source);
   }
   return result;
 }
 
-/**
- * Loads and binds the recipes `run` needs, filtered to the input ids in `only`
- * when given.
- *
- * @param sources - Recipe files or directories (or recipes the MCP server was handed inline).
- * @param only - Input recipe ids to keep; empty keeps all.
- * @returns The bound set.
- * @throws Error when there is not exactly one output recipe.
- * @throws RecipeValidationError, RecipeBindingError on a bad recipe.
- */
+// src/run/load-for-run.use-case.ts
 async function loadForRun(sources, only) {
   const files = await readRecipeFiles(sources);
   if (files.outputs.length !== 1) throw new Error(`expected exactly one output recipe, found ${files.outputs.length}`);
-  const output = parseOutputRecipe(files.outputs[0].recipe, files.outputs[0].path);
-  const inputs = files.inputs.map(file => parseInputRecipe(file.recipe, file.path)).filter(input => only.length === 0 || only.includes(input.id));
+  const output = parseOutputRecipe2(files.outputs[0].recipe, files.outputs[0].path);
+  const inputs = files.inputs.map((file) => parseInputRecipe(file.recipe, file.path)).filter((input) => only.length === 0 || only.includes(input.id));
   return bindRecipeSet(output, inputs);
 }
 
-/**
- * Crawls the recipes at `paths` and reports what happened.
- *
- * `--dry-run` caps every input at one record, attaches the scope each record
- * was mapped from, and prints them side by side instead of writing them, so a
- * recipe under construction can be checked without a full run.
- *
- * @param command - The parsed `run` command.
- * @param terminal - Where records, the trace and errors go.
- * @returns The exit code: 0, or 1 on a load failure or a recipe error.
- */
+// src/run/run-recipes.use-case.ts
 async function runRecipes(command, terminal) {
   let set;
   try {
@@ -835,18 +503,12 @@ async function runRecipes(command, terminal) {
     return 1;
   }
   if (set.inputs.length === 0) {
-    terminal.err(command.only.length > 0 ? `no input recipe matches --only ${command.only.join(', ')}` : 'no input recipes found');
+    terminal.err(command.only.length > 0 ? `no input recipe matches --only ${command.only.join(", ")}` : "no input recipes found");
     return 1;
   }
-  // The extension of --out names the format: one that names none is refused here, before the crawl, not after it.
   let sink;
   try {
-    sink = command.dryRun || command.out === undefined ? memorySink() : fileSink(command.out, {
-      append: command.append,
-      browser: {
-        executablePath: command.options.browserPath
-      }
-    });
+    sink = command.dryRun || command.out === void 0 ? memorySink() : fileSink2(command.out, { append: command.append, browser: { executablePath: command.options.browserPath } });
   } catch (error) {
     terminal.err(error instanceof Error ? error.message : String(error));
     return 1;
@@ -857,9 +519,8 @@ async function runRecipes(command, terminal) {
   const emitted = [];
   try {
     access = await resolveAccess(command.options);
-    plugins = command.options.plugins === undefined ? undefined : await loadPlugins(command.options.plugins);
-    // Read before the crawl: --diff may name the very file --out is about to overwrite.
-    previous = command.diff === undefined ? undefined : await readRecordsFile(command.diff);
+    plugins = command.options.plugins === void 0 ? void 0 : await loadPlugins(command.options.plugins);
+    previous = command.diff === void 0 ? void 0 : await readRecordsFile3(command.diff);
   } catch (error) {
     terminal.err(error instanceof Error ? error.message : String(error));
     return 1;
@@ -870,9 +531,7 @@ async function runRecipes(command, terminal) {
     throttle: throttleFor(command, access?.throttle),
     profilesDir: command.profiles,
     parallel: command.parallel,
-    retry: command.retries === undefined ? undefined : {
-      attempts: command.retries
-    },
+    retry: command.retries === void 0 ? void 0 : { attempts: command.retries },
     hooks: plugins?.hooks,
     accessPlugins: plugins?.accessPlugins,
     captchaSolvers: plugins?.captchaSolvers,
@@ -883,144 +542,100 @@ async function runRecipes(command, terminal) {
       executablePath: command.options.browserPath,
       ignoreHTTPSErrors: command.options.insecureTls
     },
-    onEvent: event => {
-      if (previous !== undefined && event.type === 'record:emit') emitted.push(event.data);
+    onEvent: (event) => {
+      if (previous !== void 0 && event.type === "record:emit") emitted.push(event.data);
       onEvent(event, command, terminal);
     }
   });
   try {
-    const inputs = command.dryRun ? set.inputs.map(input => ({
-      ...input,
-      limits: {
-        ...input.limits,
-        maxRecords: 1
-      }
-    })) : set.inputs;
+    const inputs = command.dryRun ? set.inputs.map((input) => ({ ...input, limits: { ...input.limits, maxRecords: 1 } })) : set.inputs;
     const report = await crawler.run(new RecipeSet(set.output, inputs));
-    if (command.out === undefined && !command.dryRun) for (const record of sink.records) terminal.out(JSON.stringify(record.data));
+    if (command.out === void 0 && !command.dryRun) for (const record of sink.records) terminal.out(JSON.stringify(record.data));
     for (const recipe of report.recipes) {
-      terminal.err(`${recipe.recipeId}${recipe.variant === undefined ? '' : ` [${variantLabel(recipe.variant)}]`}: ${recipe.emitted} emitted, ${recipe.rejected} rejected, ${recipe.duplicates} duplicates, ${recipe.skipped} skipped, ${recipe.stepsSkipped > 0 ? `${recipe.stepsSkipped} steps skipped (see --trace), ` : ''}${recipe.pages} pages, ${recipe.durationMs} ms${recipe.error === undefined ? '' : `, stopped: ${recipe.error}`}`);
+      terminal.err(`${recipe.recipeId}${recipe.variant === void 0 ? "" : ` [${variantLabel(recipe.variant)}]`}: ${recipe.emitted} emitted, ${recipe.rejected} rejected, ${recipe.duplicates} duplicates, ${recipe.skipped} skipped, ${recipe.stepsSkipped > 0 ? `${recipe.stepsSkipped} steps skipped (see --trace), ` : ""}${recipe.pages} pages, ${recipe.durationMs} ms${recipe.error === void 0 ? "" : `, stopped: ${recipe.error}`}`);
     }
-    if (!command.dryRun) terminal.err(`${report.records} records${report.sink.location === undefined ? '' : ` written to ${report.sink.location}`}`);
-    if (previous !== undefined) {
-      const diff = diffRecords(previous, emitted, diffOptionsFor(set.output));
-      terminal.err(`compared with ${command.diff ?? ''}:`);
+    if (!command.dryRun) terminal.err(`${report.records} records${report.sink.location === void 0 ? "" : ` written to ${report.sink.location}`}`);
+    if (previous !== void 0) {
+      const diff = diffRecords2(previous, emitted, diffOptionsFor(set.output));
+      terminal.err(`compared with ${command.diff ?? ""}:`);
       for (const line of diffReport(diff)) terminal.err(`  ${line}`);
-      if (command.changes !== undefined) await writeChanges(command.changes, diff);
+      if (command.changes !== void 0) await writeChanges(command.changes, diff);
     }
-    return report.recipes.some(recipe => recipe.error !== undefined) ? 1 : 0;
+    return report.recipes.some((recipe) => recipe.error !== void 0) ? 1 : 0;
   } finally {
     await crawler.close();
   }
 }
-/** The access config's throttle, with `--host-delay` / `--host-concurrency` over its defaults. */
 function throttleFor(command, fromConfig) {
-  const {
-    delayMs,
-    concurrency
-  } = command.throttle;
-  if (delayMs === undefined && concurrency === undefined) return fromConfig;
-  return {
-    ...fromConfig,
-    ...(delayMs !== undefined && {
-      delayMs
-    }),
-    ...(concurrency !== undefined && {
-      concurrency
-    })
-  };
+  const { delayMs, concurrency } = command.throttle;
+  if (delayMs === void 0 && concurrency === void 0) return fromConfig;
+  return { ...fromConfig, ...delayMs !== void 0 && { delayMs }, ...concurrency !== void 0 && { concurrency } };
 }
 function onEvent(event, command, terminal) {
   if (command.trace) {
     const line = traceLine(event);
-    if (line !== undefined) terminal.err(line);
+    if (line !== void 0) terminal.err(line);
   }
-  if (command.dryRun && event.type === 'record:emit') {
+  if (command.dryRun && event.type === "record:emit") {
     terminal.out(`--- ${event.recipeId} ---`);
     terminal.out(`scope: ${JSON.stringify(event.scope, null, 2)}`);
     terminal.out(`record: ${JSON.stringify(event.data, null, 2)}`);
   }
-  if (command.dryRun && event.type === 'record:reject') terminal.out(`--- ${event.recipeId}: rejected (${event.field}: ${event.reason}) ---\nscope: ${JSON.stringify(event.scope, null, 2)}`);
+  if (command.dryRun && event.type === "record:reject") terminal.out(`--- ${event.recipeId}: rejected (${event.field}: ${event.reason}) ---
+scope: ${JSON.stringify(event.scope, null, 2)}`);
 }
 function loadErrorLines(error) {
-  if (error instanceof RecipeValidationError) return error.issues.map(issue => `${error.source}: ${issue.path === '' ? '(root)' : issue.path}: ${issue.message}`);
-  if (error instanceof RecipeBindingError) return error.issues.map(issue => `${issue.recipeId}: ${issue.path}: ${issue.message}`);
+  if (error instanceof RecipeValidationError2) return error.issues.map((issue) => `${error.source}: ${issue.path === "" ? "(root)" : issue.path}: ${issue.message}`);
+  if (error instanceof RecipeBindingError) return error.issues.map((issue) => `${issue.recipeId}: ${issue.path}: ${issue.message}`);
   return [error instanceof Error ? error.message : String(error)];
 }
 
-/**
- * Runs `opencraw studio [folder]`: imports `@opencraw/studio` lazily and
- * delegates to its own `main`, which starts the server, prints the URL with
- * the token, and keeps running until interrupted (Ctrl+C) — the cli's own
- * call does not return before that. `@opencraw/studio` is an optional peer
- * dependency (`peerDependenciesMeta`), never a hard one: the cli stays light
- * for callers who only need to crawl. When it is not installed, this prints
- * how to add it instead of letting a raw `ERR_MODULE_NOT_FOUND` stack trace
- * through.
- *
- * @param folder - The recipe folder to open; `@opencraw/studio`'s own default (the current directory) when omitted.
- * @param terminal - Where output goes.
- * @param importStudio - How the module is loaded; the real dynamic `import()` by default, replaced in tests.
- * @param pluginsFile - A hooks or plugins module (`--hooks`, issue #150), loaded here, on the command line's own authority, and handed to Studio: the server never loads code itself.
- * @param load - How the module is read; `loadPlugins` unless a test says otherwise.
- * @param open - A folder, recipe file or document (`--open`, issue #235): the printed link opens it straight away.
- * @returns The exit code: 0 once the server has stopped, 1 when `@opencraw/studio` is missing.
- */
-async function runStudio(folder, terminal, importStudio = () => import('@opencraw/studio'), pluginsFile, load = loadPlugins, open) {
+// src/studio/run-studio.use-case.ts
+async function runStudio(folder, terminal, importStudio = () => import("@opencraw/studio"), pluginsFile, load = loadPlugins, open) {
   let studio;
   try {
     studio = await importStudio();
   } catch (error) {
     if (!isModuleNotFound(error)) throw error;
-    terminal.err('the studio is not installed: run `npm install @opencraw/studio`, then try again');
+    terminal.err("the studio is not installed: run `npm install @opencraw/studio`, then try again");
     return 1;
   }
-  const plugins = pluginsFile === undefined ? undefined : {
-    source: pluginsFile,
-    ...(await load(pluginsFile))
-  };
-  await studio.main(folder === undefined ? [] : [folder], {
-    plugins,
-    open
-  });
+  const plugins = pluginsFile === void 0 ? void 0 : { source: pluginsFile, ...await load(pluginsFile) };
+  await studio.main(folder === void 0 ? [] : [folder], { plugins, open });
   return 0;
 }
 function isModuleNotFound(error) {
-  return error instanceof Error && 'code' in error && error.code === 'ERR_MODULE_NOT_FOUND';
+  return error instanceof Error && "code" in error && error.code === "ERR_MODULE_NOT_FOUND";
 }
 
-/**
- * Loads and binds recipe files, printing every problem with its JSON path.
- *
- * @param paths - Recipe files or directories.
- * @param terminal - Where results go.
- * @returns The exit code: 0 when the recipes bind cleanly, 1 otherwise.
- */
+// src/validate/validate-recipes.use-case.ts
+import { RecipeBindingError as RecipeBindingError2, RecipeValidationError as RecipeValidationError3, bindRecipeSet as bindRecipeSet2, parseInputRecipe as parseInputRecipe2, parseOutputRecipe as parseOutputRecipe3 } from "@opencraw/core";
 async function validateRecipes(paths, terminal) {
   const files = await readRecipeFiles(paths);
   for (const path of files.others) terminal.err(`${path}: not a recipe ("kind" is missing or not "input"/"output")`);
   if (files.outputs.length === 0) {
-    terminal.err('no output recipe found');
+    terminal.err("no output recipe found");
     return 1;
   }
   if (files.outputs.length > 1) {
-    terminal.err(`more than one output recipe: ${files.outputs.map(file => file.path).join(', ')}`);
+    terminal.err(`more than one output recipe: ${files.outputs.map((file) => file.path).join(", ")}`);
     return 1;
   }
   let ok = true;
-  const output = parseOne(files.outputs[0].path, files.outputs[0].recipe, parseOutputRecipe, terminal);
-  const inputs = files.inputs.flatMap(file => {
-    const parsed = parseOne(file.path, file.recipe, parseInputRecipe, terminal);
-    return parsed === undefined ? [] : [parsed];
+  const output = parseOne(files.outputs[0].path, files.outputs[0].recipe, parseOutputRecipe3, terminal);
+  const inputs = files.inputs.flatMap((file) => {
+    const parsed = parseOne(file.path, file.recipe, parseInputRecipe2, terminal);
+    return parsed === void 0 ? [] : [parsed];
   });
-  ok &&= output !== undefined && inputs.length === files.inputs.length;
-  if (output === undefined) return 1;
+  ok &&= output !== void 0 && inputs.length === files.inputs.length;
+  if (output === void 0) return 1;
   try {
-    const set = bindRecipeSet(output, inputs);
-    terminal.out(`ok: ${set.output.id} <- ${set.inputs.map(input => input.id).join(', ') || '(no inputs)'}`);
+    const set = bindRecipeSet2(output, inputs);
+    terminal.out(`ok: ${set.output.id} <- ${set.inputs.map((input) => input.id).join(", ") || "(no inputs)"}`);
   } catch (error) {
     ok = false;
-    if (error instanceof RecipeBindingError) for (const issue of error.issues) terminal.err(`${issue.recipeId}: ${issue.path}: ${issue.message}`);else terminal.err(String(error));
+    if (error instanceof RecipeBindingError2) for (const issue of error.issues) terminal.err(`${issue.recipeId}: ${issue.path}: ${issue.message}`);
+    else terminal.err(String(error));
   }
   return ok ? 0 : 1;
 }
@@ -1028,21 +643,14 @@ function parseOne(path, recipe, parse, terminal) {
   try {
     return parse(recipe, path);
   } catch (error) {
-    if (error instanceof RecipeValidationError) for (const issue of error.issues) terminal.err(`${path}: ${issue.path}: ${issue.message}`);else terminal.err(`${path}: ${String(error)}`);
-    return undefined;
+    if (error instanceof RecipeValidationError3) for (const issue of error.issues) terminal.err(`${path}: ${issue.path}: ${issue.message}`);
+    else terminal.err(`${path}: ${String(error)}`);
+    return void 0;
   }
 }
 
-const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
-/**
- * Runs one cli invocation: parses argv, dispatches to a use case, writes
- * through `terminal`. Never throws; a bad command or a use case failure both
- * become a non-zero return.
- *
- * @param argv - Arguments after the program name.
- * @param terminal - Where output goes.
- * @returns The process exit code.
- */
+// src/main.ts
+var VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 async function main(argv, terminal) {
   let command;
   try {
@@ -1053,57 +661,63 @@ async function main(argv, terminal) {
     return 1;
   }
   switch (command.name) {
-    case 'help':
-      {
-        terminal.out(USAGE);
-        return 0;
-      }
-    case 'version':
-      {
-        terminal.out(VERSION);
-        return 0;
-      }
-    case 'validate':
-      {
-        return validateRecipes(command.paths, terminal);
-      }
-    case 'run':
-      {
-        return runRecipes(command, terminal);
-      }
-    case 'probe':
-      {
-        return probePage(command.url, {
-          browser: command.browser,
-          ...command.options
-        }, terminal);
-      }
-    case 'diff':
-      {
-        return diffFiles(command, terminal);
-      }
-    case 'export':
-      {
-        return exportRecords(command, terminal);
-      }
-    case 'studio':
-      {
-        return runStudio(command.folder, terminal, undefined, command.plugins, undefined, command.open);
-      }
+    case "help": {
+      terminal.out(USAGE);
+      return 0;
+    }
+    case "version": {
+      terminal.out(VERSION);
+      return 0;
+    }
+    case "validate": {
+      return validateRecipes(command.paths, terminal);
+    }
+    case "run": {
+      return runRecipes(command, terminal);
+    }
+    case "probe": {
+      return probePage(command.url, { browser: command.browser, ...command.options }, terminal);
+    }
+    case "diff": {
+      return diffFiles(command, terminal);
+    }
+    case "export": {
+      return exportRecords(command, terminal);
+    }
+    case "studio": {
+      return runStudio(command.folder, terminal, void 0, command.plugins, void 0, command.open);
+    }
   }
 }
 
-/** The process's stdout and stderr. */
+// src/terminal/terminal.client.ts
 function processTerminal() {
   return {
-    out: line => {
-      process.stdout.write(`${line}\n`);
+    out: (line) => {
+      process.stdout.write(`${line}
+`);
     },
-    err: line => {
-      process.stderr.write(`${line}\n`);
+    err: (line) => {
+      process.stderr.write(`${line}
+`);
     }
   };
 }
-
-export { USAGE, diffReport, loadForRun, loadHooks, loadPlugins, main, parseArguments, probeReport, probeUrl, processTerminal, readRecipeFiles, resolveAccess, runStudio, writeChanges };
+export {
+  USAGE,
+  diffReport,
+  findData2 as findData,
+  loadForRun,
+  loadHooks,
+  loadPlugins,
+  main,
+  parseArguments,
+  probeReport,
+  probeUrl,
+  processTerminal,
+  readRecipeFiles,
+  resolveAccess,
+  runStudio,
+  writeChanges
+};
 //# sourceMappingURL=index.esm.js.map