@opencraw/cli 0.1.17 → 0.1.19

package/dist/index.esm.js

@@ -1,8 +1,10 @@
 import { parseArgs } from 'node:util';
 import { writeFile } from 'node:fs/promises';
-import { readableKey, readRecordsFile, diffRecords, loadAccessConfig, htmlTableSheets, HostAllowlist, AccessBroker, HttpClient, parseXml, BrowserClient, readRecipeSource, parseOutputRecipe, parseInputRecipe, bindRecipeSet, memorySink, jsonLinesSink, createCrawler, RecipeSet, variantLabel, diffOptionsFor, RecipeValidationError, RecipeBindingError, traceLine } from '@opencraw/core';
+import { readableKey, readRecordsFile, diffRecords, loadAccessConfig, HostAllowlist, AccessBroker, HttpClient, parseXml, BrowserClient, readRecipeSource, parseOutputRecipe, parseInputRecipe, bindRecipeSet, memorySink, jsonLinesSink, createCrawler, RecipeSet, variantLabel, diffOptionsFor, RecipeValidationError, 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]
@@ -457,455 +459,6 @@ function hookExports(exported) {
   return Object.fromEntries(named);
 }
 
-/**
- * Finds where a fetched page's data lives: JSON-LD blocks, inline JSON objects
- * big enough to matter, URLs that look like a data endpoint, script hosts and
- * links whose path suggests an API. Pattern-matching only; it never fetches.
- */
-const MIN_INLINE_SIZE = 200;
-const JSON_LD = /<script[^\s>]*\s+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
-const INLINE_SCRIPT = /<script(?![^>]*\ssrc=)(?![^>]*\stype=["']application\/ld\+json["'])[^>]*>([\s\S]*?)<\/script>/gi;
-const DATA_ATTR = /data-[\w-]+=["'](\{[\s\S]*?\})["']/g;
-const SCRIPT_SRC = /<script[^\s>]*\s+src=["']([^"']+)["']/gi;
-const HREF_OR_JSON_URL = /["'](https?:\/\/[^"'\s]+\.json[^"'\s]*|\/[^"'\s]*\.json[^"'\s]*)["']/g;
-const LINK = /<a[^\s>]*\s+href=["']([^"']+)["']/gi;
-/**
- * Scans a page's HTML for data-shaped things.
- *
- * @param html - The document.
- * @returns What was found, each list capped at a handful of entries.
- */
-function findData(html) {
-  return {
-    jsonLd: jsonLdBlocks(html),
-    inlineJson: inlineJsonBlocks(html),
-    jsonUrls: unique(matchesOf(HREF_OR_JSON_URL, html)).slice(0, 10),
-    scriptHosts: scriptHosts(html),
-    apiLinks: apiLinks(html)
-  };
-}
-function jsonLdBlocks(html) {
-  const findings = [];
-  for (const text of matchesOf(JSON_LD, html)) {
-    const parsed = tryParse(text);
-    if (parsed === undefined) continue;
-    findings.push(...entriesOf(parsed));
-  }
-  return findings.slice(0, 10);
-}
-/** Every plain object in a JSON-LD block (it may be one object or an array of them), as a finding. */
-function entriesOf(parsed) {
-  const list = Array.isArray(parsed) ? parsed : [parsed];
-  return list.flatMap(entry => {
-    if (typeof entry !== 'object' || entry === null) return [];
-    const record = entry;
-    const type = record['@type'];
-    return [{
-      types: Array.isArray(type) ? type.join(',') : String(type ?? '?'),
-      keys: Object.keys(record).length
-    }];
-  });
-}
-function inlineJsonBlocks(html) {
-  const findings = [];
-  for (const text of matchesOf(INLINE_SCRIPT, html)) findings.push(...objectsIn(text, 'inline script'));
-  for (const text of matchesOf(DATA_ATTR, html, 1)) findings.push(...objectsIn(text, 'data-* attribute'));
-  return findings.filter(finding => finding.size >= MIN_INLINE_SIZE).sort((a, b) => b.size - a.size).slice(0, 10);
-}
-/** Every `{...}` in a text that parses as JSON, by scanning for balanced braces (regex cannot nest). */
-function objectsIn(text, where) {
-  const found = [];
-  for (let at = text.indexOf('{'); at !== -1; at = text.indexOf('{', at + 1)) {
-    const end = matchingBrace(text, at);
-    if (end === -1) continue;
-    const candidate = text.slice(at, end + 1);
-    const parsed = tryParse(candidate);
-    if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-      found.push({
-        where,
-        keys: Object.keys(parsed),
-        size: candidate.length
-      });
-      at = end;
-    }
-  }
-  return found;
-}
-function matchingBrace(text, open) {
-  let depth = 0;
-  for (let at = open; at < text.length; at += 1) {
-    if (text[at] === '{') depth += 1;else if (text[at] === '}') {
-      depth -= 1;
-      if (depth === 0) return at;
-    }
-  }
-  return -1;
-}
-function scriptHosts(html) {
-  const hosts = matchesOf(SCRIPT_SRC, html).map(src => {
-    try {
-      return new URL(src).host;
-    } catch {
-      return;
-    }
-  }).filter(host => host !== undefined);
-  return unique(hosts).slice(0, 10);
-}
-function apiLinks(html) {
-  return unique(matchesOf(LINK, html).filter(href => /\bapi\b/i.test(href))).slice(0, 10);
-}
-function matchesOf(pattern, text, group = 1) {
-  return Array.from(text.matchAll(pattern), match => match[group]);
-}
-function unique(values) {
-  return [...new Set(values)];
-}
-function tryParse(text) {
-  try {
-    return JSON.parse(text.trim());
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Whether a cell holds a figure (an amount, a count, a date written in
- * digits) rather than words: it starts with a number, or its digits are at
- * least as many as its letters. `2,820`, `$560`, `2659 $560`, `(£0.58m)`,
- * `-3 days` and `2026` are figures; `FY26 Lodging Rate`,
- * `FM Classes A, B1 & C3` and `(APRIL 1, 2020)` are words that happen to
- * contain digits.
- *
- * @param cell - The cell's text.
- * @returns Whether it is a figure.
- */
-function isFigure(cell) {
-  if (/^[\s(+\-–−<>=~$€£¥]*\d/u.test(cell)) return true;
-  const digits = cell.match(/\d/g)?.length ?? 0;
-  return digits > 0 && digits >= (cell.match(/\p{L}/gu)?.length ?? 0);
-}
-/**
- * A row that reads like a table's header: at least two cells, none a figure.
- *
- * @param cells - The row's non-empty cells.
- * @returns Whether it could be a header.
- */
-function isHeaderRow(cells) {
-  return cells.length >= 2 && cells.every(cell => !isFigure(cell));
-}
-/**
- * A row that reads like a table's data: at least two cells, one a figure.
- *
- * @param cells - The row's non-empty cells.
- * @returns Whether it looks like data.
- */
-function isDataRow(cells) {
-  return cells.length >= 2 && cells.some(cell => isFigure(cell));
-}
-
-/** Rows shown per sheet in a probe, at most. */
-const ROW_LIMIT$1 = 20;
-/** How far below a header row a probe looks for the first data row. */
-const LOOKAHEAD = 3;
-/**
- * Summarises a workbook for someone writing a recipe: its sheets, what their
- * rows look like and where the tables start, so a `table` extract's `sheet`,
- * `selector` and columns can be read off the result instead of guessed.
- *
- * @param document - The read workbook.
- * @returns The findings.
- */
-function describeWorkbook(document) {
-  const visible = document.sheets.filter(sheet => sheet.hidden !== true);
-  return {
-    ...(document.csv !== undefined && {
-      csv: document.csv
-    }),
-    sheets: document.sheets.map(sheet => ({
-      name: sheet.name,
-      hidden: sheet.hidden === true,
-      rows: sheet.rows.length,
-      columns: Math.max(0, ...sheet.rows.map(row => row.length))
-    })),
-    rows: visible.flatMap(sheet => filledRows(sheet).slice(0, ROW_LIMIT$1).map(({
-      index,
-      cells
-    }) => ({
-      sheet: sheet.name,
-      row: index + 1,
-      text: cells.join(' | ')
-    }))),
-    headers: visible.flatMap(sheet => headersOf(sheet))
-  };
-}
-function headersOf(sheet) {
-  const rows = filledRows(sheet);
-  const merged = mergedRows(sheet);
-  const headers = [];
-  // The table a row belongs to: the header it follows, until an empty row ends the block.
-  let table;
-  for (const [position, {
-    index,
-    cells
-  }] of rows.entries()) {
-    const previous = rows[position - 1]?.index;
-    if (previous === undefined || index > previous + 1) table = undefined;
-    const secondHeaderRow = table?.merged === true && index === table.header + 1;
-    if (table !== undefined && !secondHeaderRow) continue;
-    if (!isHeaderRow(cells) || rows.slice(position + 1, position + 1 + LOOKAHEAD).every(row => !isDataRow(row.cells))) continue;
-    const header = {
-      sheet: sheet.name,
-      row: index + 1,
-      text: cells.join(' | '),
-      selector: `^${escape$1(cells[0])}`
-    };
-    headers.push(merged.has(index) ? {
-      ...header,
-      hint: 'merged header cells: try "headerRows": 2'
-    } : header);
-    table ??= {
-      header: index,
-      merged: merged.has(index)
-    };
-  }
-  return headers;
-}
-/** The non-empty rows, as their non-empty cells, whitespace collapsed. */
-function filledRows(sheet) {
-  const hidden = new Set(sheet.hiddenRows);
-  return sheet.rows.flatMap((row, index) => {
-    const cells = row.map(cell => String(cell).replaceAll(/\s+/g, ' ').trim()).filter(cell => cell !== '');
-    return cells.length === 0 || hidden.has(index) ? [] : [{
-      index,
-      cells
-    }];
-  });
-}
-/** Rows a merged range starts on. */
-function mergedRows(sheet) {
-  const rows = new Set();
-  const merges = sheet.merges ?? [];
-  for (const reference of merges) {
-    const match = /^\$?[A-Z]+\$?(\d+)/i.exec(reference);
-    if (match !== null) rows.add(Number(match[1]) - 1);
-  }
-  return rows;
-}
-function escape$1(text) {
-  return text.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`);
-}
-
-/** Short text boxes on one slide from which a probe suggests reading them as a table. */
-const GRID_BOXES = 6;
-const SHORT_TEXT = 40;
-/**
- * Summarises a deck for someone writing a recipe: its slides, where the native
- * tables start, what the charts hold, and which slides lay text boxes out as
- * a table.
- *
- * @param document - The read deck.
- * @returns The findings.
- */
-function describeDeck(document) {
-  return {
-    width: document.width,
-    height: document.height,
-    slides: document.slides.map(slide => ({
-      number: slide.number,
-      title: slide.title ?? '',
-      hidden: slide.hidden,
-      shapes: slide.shapes.length,
-      tables: slide.tables.length,
-      charts: slide.charts.length
-    })),
-    headers: document.slides.flatMap(slide => describeWorkbook({
-      sheets: slide.tables
-    }).headers.map(({
-      sheet: _sheet,
-      row: _row,
-      ...header
-    }) => ({
-      slide: slide.number,
-      ...header
-    }))),
-    charts: document.slides.flatMap(slide => slide.charts.map(chart => ({
-      slide: slide.number,
-      type: chart.type,
-      ...(chart.title !== undefined && {
-        title: chart.title
-      }),
-      series: chart.series.map(series => ({
-        name: series.name,
-        points: series.values.length
-      }))
-    }))),
-    grids: document.slides.flatMap(slide => {
-      const boxes = slide.shapes.filter(shape => shape.placeholder === undefined && shape.text.length <= SHORT_TEXT).length;
-      return boxes >= GRID_BOXES ? [{
-        slide: slide.number,
-        title: slide.title ?? '',
-        boxes
-      }] : [];
-    })
-  };
-}
-
-const SECTION = /<section data-heading="([^"]*)" data-level="(\d)">/g;
-const FRONT_MATTER = /<script type="application\/json" data-front-matter>([\s\S]*?)<\/script>/;
-/**
- * Summarises an HTML document for a `table` extract, and, when it is rendered
- * Markdown or a Word document, its outline (and Markdown's front matter).
- *
- * @param html - The document.
- * @param markdown - Whether it was rendered from Markdown or Word, and so has sections.
- * @returns The findings.
- */
-function describeHtml(html, markdown) {
-  const tables = htmlTableSheets(html);
-  const headers = describeWorkbook({
-    sheets: tables
-  }).headers.map(({
-    sheet,
-    row: _row,
-    ...header
-  }) => ({
-    table: sheet,
-    ...header
-  }));
-  if (!markdown) return {
-    tables: headers
-  };
-  const outline = Array.from(html.matchAll(SECTION), ([, heading, level]) => ({
-    level: Number(level),
-    heading: unescape(heading),
-    selector: `section[data-heading='${unescape(heading).replaceAll("'", String.raw`\'`)}' i]`
-  }));
-  const front = FRONT_MATTER.exec(html)?.[1];
-  const data = front === undefined ? undefined : JSON.parse(front);
-  return {
-    tables: headers,
-    outline,
-    frontMatter: typeof data === 'object' && data !== null && !Array.isArray(data) ? Object.keys(data) : []
-  };
-}
-function unescape(text) {
-  return text.replaceAll('&quot;', '"').replaceAll('&lt;', '<').replaceAll('&amp;', '&');
-}
-
-/** How deep a probe describes a JSON document. */
-const DEPTH$1 = 4;
-/** Keys shown per object, at most. */
-const KEY_LIMIT = 25;
-/** Entries of a record list whose keys are compared. */
-const SAMPLE = 50;
-/** A sample value longer than this is cut. */
-const SAMPLE_CHARS$1 = 40;
-/**
- * Summarises JSON data for someone writing a recipe: its shape, and where its
- * record lists are, so a `jsonpath` selector can be read off the result.
- *
- * @param data - The parsed document.
- * @param format - What it was read as (`json`, `jsonl`, `yaml`).
- * @returns The findings.
- */
-function describeJson(data, format) {
-  const tree = [];
-  const lists = [];
-  walk$1(data, '$', 0, tree, lists);
-  return {
-    format,
-    type: typeOf(data),
-    tree,
-    lists: lists.sort((first, second) => second.length - first.length)
-  };
-}
-function walk$1(value, path, depth, tree, lists) {
-  if (Array.isArray(value)) {
-    const objects = value.filter(entry => isObject(entry));
-    if (objects.length >= 2 && objects.length === value.length) lists.push({
-      path: `${path}[*]`,
-      length: value.length,
-      keys: sharedKeys(objects.slice(0, SAMPLE))
-    });
-    if (depth > 0) tree.push(`${path}  ${typeOf(value)}`);
-    if (depth < DEPTH$1 && value.length > 0) walk$1(value[0], `${path}[*]`, depth + 1, tree, lists);
-    return;
-  }
-  if (isObject(value)) {
-    if (depth > 0) tree.push(`${path}  object`);
-    if (depth >= DEPTH$1) return;
-    for (const [key, child] of Object.entries(value).slice(0, KEY_LIMIT)) walk$1(child, childPath(path, key), depth + 1, tree, lists);
-    return;
-  }
-  tree.push(`${path}  ${typeOf(value)}${sample(value)}`);
-}
-function typeOf(value) {
-  if (Array.isArray(value)) {
-    const kinds = [...new Set(value.slice(0, SAMPLE).map(entry => typeOf(entry).split(' ', 1)[0]))];
-    return `array (${value.length})${kinds.length === 0 ? '' : ` of ${kinds.join(' | ')}`}`;
-  }
-  if (value === null) return 'null';
-  return typeof value === 'object' ? 'object' : typeof value;
-}
-function sample(value) {
-  if (value === null || value === undefined) return '';
-  const text = JSON.stringify(value);
-  return ` ${text.length > SAMPLE_CHARS$1 ? `${text.slice(0, SAMPLE_CHARS$1)}…` : text}`;
-}
-function sharedKeys(objects) {
-  const [first, ...rest] = objects;
-  return Object.keys(first).filter(key => rest.every(object => Object.hasOwn(object, key)));
-}
-function childPath(path, key) {
-  return /^[$A-Z_][\w$]*$/i.test(key) ? `${path}.${key}` : `${path}['${key.replaceAll("'", String.raw`\'`)}']`;
-}
-function isObject(value) {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-/** Rows shown in a probe, at most. */
-const ROW_LIMIT = 80;
-/**
- * Summarises a PDF for someone writing a recipe: what the rows look like, and
- * where the tables start, so a `table` extract's selector and columns can be
- * read off the result instead of guessed.
- *
- * @param document - The read PDF.
- * @returns The findings.
- */
-function describePdf(document) {
-  const rows = document.pages.flatMap(page => page.rows.map((row, index) => ({
-    page: page.number,
-    row,
-    next: page.rows.slice(index + 1, index + 3)
-  })));
-  const headers = rows.filter(({
-    row,
-    next
-  }) => isHeaderRow(row.cells.map(cell => cell.text)) && next.some(candidate => isDataRow(candidate.cells.map(cell => cell.text))));
-  return {
-    pages: document.pages.length,
-    rows: rows.slice(0, ROW_LIMIT).map(({
-      page,
-      row
-    }) => ({
-      page,
-      text: row.cells.map(cell => cell.text).join(' | ')
-    })),
-    headers: headers.map(({
-      page,
-      row
-    }) => ({
-      page,
-      text: row.cells.map(cell => cell.text).join(' | '),
-      selector: `^${escape(row.cells[0].text)}`
-    }))
-  };
-}
-function escape(text) {
-  return text.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`);
-}
-
 /**
  * Renders a probe's findings as text.
  *
@@ -999,86 +552,6 @@ function section(title, rows) {
   return [`${title}:`, ...rows, ''].join('\n');
 }
 
-/** How deep a probe describes an XML document. */
-const DEPTH = 5;
-/** Distinct paths shown, at most. */
-const PATH_LIMIT = 60;
-/** A sample value longer than this is cut. */
-const SAMPLE_CHARS = 40;
-const ELEMENT = 1;
-/**
- * Summarises an XML document for someone writing a recipe: its namespaces
- * (and the `namespaces` a query needs), the elements that repeat (the
- * records a `forEach` walks), and its structure.
- *
- * @param document - A parsed document (`parseXml` from the core), read through the W3C DOM properties.
- * @returns The findings.
- */
-function describeXml(document) {
-  const root = document.documentElement;
-  if (root === null) return {
-    root: '',
-    namespaces: {},
-    lists: [],
-    tree: []
-  };
-  const paths = new Map();
-  walk(root, `/${root.localName ?? ''}`, 1, paths);
-  const namespaces = Object.fromEntries(Array.from(root.attributes ?? [], attribute => attribute).filter(attribute => attribute.name === 'xmlns' || attribute.prefix === 'xmlns').map(attribute => [attribute.name === 'xmlns' ? '' : attribute.localName, attribute.value]));
-  const lists = [...paths].filter(([, info]) => info.maxSiblings >= 2).map(([path, info]) => ({
-    path: `//${path.split('/').slice(-2).join('/')}`.replace(/^\/\/\//, '//'),
-    count: info.count,
-    children: [...info.children]
-  })).sort((first, second) => second.count - first.count);
-  const tree = [...paths].slice(0, PATH_LIMIT).map(([path, info]) => `${path}${info.count > 1 ? `  ×${info.count}` : ''}${info.attributes.size > 0 ? `  ${[...info.attributes].map(name => `@${name}`).join(' ')}` : ''}${info.sample === undefined ? '' : `  ${JSON.stringify(info.sample)}`}`);
-  const name = root.localName ?? '';
-  const sitemap = name === 'urlset' || name === 'sitemapindex' ? {
-    kind: name,
-    locations: paths.get(`/${name}/${name === 'urlset' ? 'url' : 'sitemap'}/loc`)?.count ?? 0
-  } : undefined;
-  return {
-    root: name,
-    namespaces,
-    lists,
-    tree,
-    ...(sitemap !== undefined && {
-      sitemap
-    })
-  };
-}
-function walk(element, path, depth, paths) {
-  const info = paths.get(path) ?? {
-    count: 0,
-    attributes: new Set(),
-    children: new Set(),
-    maxSiblings: 1
-  };
-  paths.set(path, info);
-  info.count += 1;
-  const attributes = element.attributes ?? [];
-  for (const attribute of attributes) {
-    if (attribute.name !== 'xmlns' && attribute.prefix !== 'xmlns') info.attributes.add(attribute.name);
-  }
-  const children = [...element.childNodes].filter(child => child.nodeType === ELEMENT);
-  if (children.length === 0) {
-    const text = (element.textContent ?? '').replaceAll(/\s+/g, ' ').trim();
-    if (text !== '' && info.sample === undefined) info.sample = text.length > SAMPLE_CHARS ? `${text.slice(0, SAMPLE_CHARS)}…` : text;
-    return;
-  }
-  const siblings = new Map();
-  for (const child of children) {
-    const name = child.localName ?? '';
-    info.children.add(name);
-    siblings.set(name, (siblings.get(name) ?? 0) + 1);
-  }
-  for (const child of children) {
-    const childPath = `${path}/${child.localName ?? ''}`;
-    if (depth < DEPTH) walk(child, childPath, depth + 1, paths);
-    const childInfo = paths.get(childPath);
-    if (childInfo !== undefined) childInfo.maxSiblings = Math.max(childInfo.maxSiblings, siblings.get(child.localName ?? '') ?? 1);
-  }
-}
-
 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;
 /**
@@ -1556,5 +1029,5 @@ function processTerminal() {
   };
 }
 
-export { USAGE, diffReport, findData, loadForRun, loadHooks, loadPlugins, main, parseArguments, probeReport, probeUrl, processTerminal, readRecipeFiles, resolveAccess, runStudio, writeChanges };
+export { USAGE, diffReport, loadForRun, loadHooks, loadPlugins, main, parseArguments, probeReport, probeUrl, processTerminal, readRecipeFiles, resolveAccess, runStudio, writeChanges };
 //# sourceMappingURL=index.esm.js.map

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

@@ -1,18 +1,6 @@
 export { probePage, probeUrl } from './probe-page.use-case.js';
 export type { ProbeResult, ProbeOptions } from './probe-page.use-case.js';
-export { findData } from './find-data.algorithm.js';
-export type { ProbeFindings, JsonLdFinding, InlineJsonFinding } from './find-data.algorithm.js';
 export { probeReport, pdfReport, workbookReport, deckReport, jsonReport, xmlReport } from './probe-report.mapper.js';
-export { describeXml } from './xml-findings.mapper.js';
-export type { XmlFindings } from './xml-findings.mapper.js';
-export { describePdf } from './pdf-findings.mapper.js';
-export type { PdfFindings } from './pdf-findings.mapper.js';
-export { describeWorkbook } from './workbook-findings.mapper.js';
-export type { WorkbookFindings } from './workbook-findings.mapper.js';
-export { describeDeck } from './deck-findings.mapper.js';
-export type { DeckFindings } from './deck-findings.mapper.js';
-export { describeJson } from './json-findings.mapper.js';
-export { describeHtml } from './html-findings.mapper.js';
-export type { HtmlFindings } from './html-findings.mapper.js';
-export type { JsonFindings } from './json-findings.mapper.js';
+export { findData } from '@opencraw/probe';
+export type { ProbeFindings, JsonLdFinding, InlineJsonFinding } from '@opencraw/probe';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/probe/probe-page.use-case.d.ts

@@ -1,13 +1,8 @@
 import type { AccessConfig, AccessPlugin } from '@opencraw/core';
+import { findData } from '@opencraw/probe';
+import type { DeckFindings, HtmlFindings, JsonFindings, PdfFindings, WorkbookFindings, XmlFindings } from '@opencraw/probe';
 import type { CommonOptions } from '../arguments/index.js';
 import type { Terminal } from '../terminal/index.js';
-import { findData } from './find-data.algorithm.js';
-import type { DeckFindings } from './deck-findings.mapper.js';
-import type { HtmlFindings } from './html-findings.mapper.js';
-import type { JsonFindings } from './json-findings.mapper.js';
-import type { PdfFindings } from './pdf-findings.mapper.js';
-import type { XmlFindings } from './xml-findings.mapper.js';
-import type { WorkbookFindings } from './workbook-findings.mapper.js';
 /** What fetching and, optionally, rendering a page found. */
 export interface ProbeResult {
     url: string;

package/dist/src/probe/probe-report.mapper.d.ts

@@ -1,10 +1,4 @@
-import type { ProbeFindings } from './find-data.algorithm.js';
-import type { DeckFindings } from './deck-findings.mapper.js';
-import type { HtmlFindings } from './html-findings.mapper.js';
-import type { JsonFindings } from './json-findings.mapper.js';
-import type { XmlFindings } from './xml-findings.mapper.js';
-import type { PdfFindings } from './pdf-findings.mapper.js';
-import type { WorkbookFindings } from './workbook-findings.mapper.js';
+import type { DeckFindings, HtmlFindings, JsonFindings, PdfFindings, ProbeFindings, WorkbookFindings, XmlFindings } from '@opencraw/probe';
 /**
  * Renders a probe's findings as text.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencraw/cli",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "type": "module",
   "main": "./dist/index.esm.js",
   "module": "./dist/index.esm.js",
@@ -24,11 +24,12 @@
     "!**/*.js.map"
   ],
   "dependencies": {
-    "@opencraw/core": "^0.1.17",
+    "@opencraw/core": "^0.1.19",
+    "@opencraw/probe": "^0.0.2",
     "playwright": "^1.63.0"
   },
   "peerDependencies": {
-    "@opencraw/studio": "^0.0.6"
+    "@opencraw/studio": "^0.0.8"
   },
   "peerDependenciesMeta": {
     "@opencraw/studio": {

package/dist/src/probe/deck-findings.mapper.d.ts

@@ -1,46 +0,0 @@
-import type { DeckDocument } from '@opencraw/core';
-/** What a probe shows of a deck (a presentation). */
-export interface DeckFindings {
-    width: number;
-    height: number;
-    slides: {
-        number: number;
-        title: string;
-        hidden: boolean;
-        shapes: number;
-        tables: number;
-        charts: number;
-    }[];
-    /** The likely header rows of native tables, with the `slide` and `selector` a `table` extract needs. */
-    headers: {
-        slide: number;
-        text: string;
-        selector: string;
-        hint?: string;
-    }[];
-    charts: {
-        slide: number;
-        type: string;
-        title?: string;
-        series: {
-            name: string;
-            points: number;
-        }[];
-    }[];
-    /** Slides whose short text boxes look like a table: read them with `"shapes": true`. */
-    grids: {
-        slide: number;
-        title: string;
-        boxes: number;
-    }[];
-}
-/**
- * Summarises a deck for someone writing a recipe: its slides, where the native
- * tables start, what the charts hold, and which slides lay text boxes out as
- * a table.
- *
- * @param document - The read deck.
- * @returns The findings.
- */
-export declare function describeDeck(document: DeckDocument): DeckFindings;
-//# sourceMappingURL=deck-findings.mapper.d.ts.map

package/dist/src/probe/find-data.algorithm.d.ts

@@ -1,36 +0,0 @@
-/**
- * Finds where a fetched page's data lives: JSON-LD blocks, inline JSON objects
- * big enough to matter, URLs that look like a data endpoint, script hosts and
- * links whose path suggests an API. Pattern-matching only; it never fetches.
- */
-export interface JsonLdFinding {
-    /** The `@type` value(s), or `'?'` when the block has none. */
-    types: string;
-    /** How many top-level keys the block has. */
-    keys: number;
-}
-export interface InlineJsonFinding {
-    /** Where it was found: a `<script>` with no `type`, or an attribute. */
-    where: string;
-    keys: string[];
-    /** Serialized size, for ranking. */
-    size: number;
-}
-export interface ProbeFindings {
-    jsonLd: JsonLdFinding[];
-    inlineJson: InlineJsonFinding[];
-    /** URLs referenced in the page whose path ends in `.json`. */
-    jsonUrls: string[];
-    /** Distinct hosts the page loads a `<script src>` from. */
-    scriptHosts: string[];
-    /** Links whose path contains `api`. */
-    apiLinks: string[];
-}
-/**
- * Scans a page's HTML for data-shaped things.
- *
- * @param html - The document.
- * @returns What was found, each list capped at a handful of entries.
- */
-export declare function findData(html: string): ProbeFindings;
-//# sourceMappingURL=find-data.algorithm.d.ts.map

package/dist/src/probe/html-findings.mapper.d.ts

@@ -1,28 +0,0 @@
-/** What a probe shows of an HTML document's tables, and of rendered Markdown's sections and front matter. */
-export interface HtmlFindings {
-    /** The likely header rows of the `<table>`s, with the `selector` a `table` extract needs. */
-    tables: {
-        table: string;
-        text: string;
-        selector: string;
-        hint?: string;
-    }[];
-    /** Rendered Markdown: its headings, each with the selector of its section. */
-    outline?: {
-        level: number;
-        heading: string;
-        selector: string;
-    }[];
-    /** Rendered Markdown: the keys of its front matter. */
-    frontMatter?: string[];
-}
-/**
- * Summarises an HTML document for a `table` extract, and, when it is rendered
- * Markdown or a Word document, its outline (and Markdown's front matter).
- *
- * @param html - The document.
- * @param markdown - Whether it was rendered from Markdown or Word, and so has sections.
- * @returns The findings.
- */
-export declare function describeHtml(html: string, markdown: boolean): HtmlFindings;
-//# sourceMappingURL=html-findings.mapper.d.ts.map

package/dist/src/probe/json-findings.mapper.d.ts

@@ -1,31 +0,0 @@
-/** What a probe shows of JSON data (a JSON, JSON Lines or YAML body). */
-export interface JsonFindings {
-    /** What the body was read as. */
-    format: string;
-    /** `object`, `array (n)`, or a scalar type. */
-    type: string;
-    /**
-     * The document's structure down to four levels, one line per node:
-     * `$.data.products  array (1240) of object`, `$.data.products[*].name  string "Pandina"`.
-     */
-    tree: string[];
-    /**
-     * Every array of objects with two entries or more, largest first: the
-     * `forEach` or `each` a recipe needs, with the keys all its entries share.
-     */
-    lists: {
-        path: string;
-        length: number;
-        keys: string[];
-    }[];
-}
-/**
- * Summarises JSON data for someone writing a recipe: its shape, and where its
- * record lists are, so a `jsonpath` selector can be read off the result.
- *
- * @param data - The parsed document.
- * @param format - What it was read as (`json`, `jsonl`, `yaml`).
- * @returns The findings.
- */
-export declare function describeJson(data: unknown, format: string): JsonFindings;
-//# sourceMappingURL=json-findings.mapper.d.ts.map

package/dist/src/probe/pdf-findings.mapper.d.ts

@@ -1,26 +0,0 @@
-import type { PdfDocument } from '@opencraw/core';
-/** What a probe shows of a PDF: its rows, and the rows that look like table headers. */
-export interface PdfFindings {
-    pages: number;
-    /** The first rows, cells separated by " | ". */
-    rows: {
-        page: number;
-        text: string;
-    }[];
-    /** Rows of text cells (no digit) with a row of data (a digit) right under them: likely table headers, with a selector that finds them. */
-    headers: {
-        page: number;
-        text: string;
-        selector: string;
-    }[];
-}
-/**
- * Summarises a PDF for someone writing a recipe: what the rows look like, and
- * where the tables start, so a `table` extract's selector and columns can be
- * read off the result instead of guessed.
- *
- * @param document - The read PDF.
- * @returns The findings.
- */
-export declare function describePdf(document: PdfDocument): PdfFindings;
-//# sourceMappingURL=pdf-findings.mapper.d.ts.map

package/dist/src/probe/table-header.policy.d.ts

@@ -1,27 +0,0 @@
-/**
- * Whether a cell holds a figure (an amount, a count, a date written in
- * digits) rather than words: it starts with a number, or its digits are at
- * least as many as its letters. `2,820`, `$560`, `2659 $560`, `(£0.58m)`,
- * `-3 days` and `2026` are figures; `FY26 Lodging Rate`,
- * `FM Classes A, B1 & C3` and `(APRIL 1, 2020)` are words that happen to
- * contain digits.
- *
- * @param cell - The cell's text.
- * @returns Whether it is a figure.
- */
-export declare function isFigure(cell: string): boolean;
-/**
- * A row that reads like a table's header: at least two cells, none a figure.
- *
- * @param cells - The row's non-empty cells.
- * @returns Whether it could be a header.
- */
-export declare function isHeaderRow(cells: readonly string[]): boolean;
-/**
- * A row that reads like a table's data: at least two cells, one a figure.
- *
- * @param cells - The row's non-empty cells.
- * @returns Whether it looks like data.
- */
-export declare function isDataRow(cells: readonly string[]): boolean;
-//# sourceMappingURL=table-header.policy.d.ts.map

package/dist/src/probe/workbook-findings.mapper.d.ts

@@ -1,44 +0,0 @@
-import type { WorkbookDocument } from '@opencraw/core';
-/** What a probe shows of a workbook (a spreadsheet or a CSV). */
-export interface WorkbookFindings {
-    /** How a CSV was read. */
-    csv?: {
-        encoding: string;
-        delimiter: string;
-    };
-    sheets: {
-        name: string;
-        hidden: boolean;
-        rows: number;
-        columns: number;
-    }[];
-    /** The first non-empty rows of each visible sheet, cells separated by " | ". */
-    rows: {
-        sheet: string;
-        row: number;
-        text: string;
-    }[];
-    /**
-     * Rows of words (no cell a figure) with a data row (a figure) just below:
-     * likely table headers, with the `sheet` and `selector` a `table` extract
-     * needs, and a hint when the header has merged cells (a header over two
-     * rows). The rows right under a header are its table's body, not headers.
-     */
-    headers: {
-        sheet: string;
-        row: number;
-        text: string;
-        selector: string;
-        hint?: string;
-    }[];
-}
-/**
- * Summarises a workbook for someone writing a recipe: its sheets, what their
- * rows look like and where the tables start, so a `table` extract's `sheet`,
- * `selector` and columns can be read off the result instead of guessed.
- *
- * @param document - The read workbook.
- * @returns The findings.
- */
-export declare function describeWorkbook(document: WorkbookDocument): WorkbookFindings;
-//# sourceMappingURL=workbook-findings.mapper.d.ts.map

package/dist/src/probe/xml-findings.mapper.d.ts

@@ -1,30 +0,0 @@
-/** What a probe shows of an XML document. */
-export interface XmlFindings {
-    /** The root element's local name. */
-    root: string;
-    /** Declared on the root: prefix (`''` for the default namespace) to URI. */
-    namespaces: Record<string, string>;
-    /** Elements that repeat under one parent, largest first: the records, with the child names they share. */
-    lists: {
-        path: string;
-        count: number;
-        children: string[];
-    }[];
-    /** One line per distinct element path (local names), with its count, attributes and a sample text. */
-    tree: string[];
-    /** For a sitemap (`urlset`, `sitemapindex`): how many locations it lists. */
-    sitemap?: {
-        kind: 'urlset' | 'sitemapindex';
-        locations: number;
-    };
-}
-/**
- * Summarises an XML document for someone writing a recipe: its namespaces
- * (and the `namespaces` a query needs), the elements that repeat (the
- * records a `forEach` walks), and its structure.
- *
- * @param document - A parsed document (`parseXml` from the core), read through the W3C DOM properties.
- * @returns The findings.
- */
-export declare function describeXml(document: unknown): XmlFindings;
-//# sourceMappingURL=xml-findings.mapper.d.ts.map