@opencraw/core 0.1.2 → 0.1.4

package/dist/markdown-document/index.d.ts

@@ -0,0 +1,3 @@
+export { readMarkdown, sectioned } from './read-markdown.client.js';
+export type { MarkdownRead } from './read-markdown.client.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/markdown-document/read-markdown.client.d.ts

@@ -0,0 +1,39 @@
+/** Markdown, rendered. */
+export interface MarkdownRead {
+    /** A full HTML document: front matter in the head, the rendered body wrapped in sections. */
+    html: string;
+    /** The front matter's data, when there is some. */
+    frontMatter: unknown;
+    warnings: string[];
+}
+/**
+ * Renders Markdown (GitHub-flavoured: tables, task lists, strikethrough,
+ * autolinks) to HTML with `marked`, imported on first use, so every `css`
+ * selector works on it:
+ *
+ * - each heading and everything up to the next heading of the same or a higher
+ *   level is wrapped in `<section data-heading="…" data-level="…">`, sections
+ *   nesting, so "the table under *Prezzi*" is one selector;
+ * - headings get slug ids (`<h2 id="prezzi">`);
+ * - a leading `---` YAML block is parsed (YAML 1.2, as `as: "yaml"` reads it)
+ *   and put in the head as `<script type="application/json" data-front-matter>`.
+ *
+ * Raw HTML in the Markdown is kept: it is data, parsed by cheerio, never run.
+ *
+ * @param text - The Markdown.
+ * @param source - Where it came from, for messages.
+ * @returns The HTML, the front matter's data and the YAML parser's warnings.
+ * @throws Error naming the source when the front matter is not YAML.
+ */
+export declare function readMarkdown(text: string, source: string): Promise<MarkdownRead>;
+/**
+ * Wraps each heading and what follows it, up to the next heading of the same
+ * or a higher level, in `<section data-heading="…" data-level="…">`, sections
+ * nesting; headings get slug ids. Rendered Markdown and Word documents both go
+ * through it, so one selector finds "the table under *Prezzi*" in either.
+ *
+ * @param html - Top-level HTML: headings among paragraphs, lists, tables.
+ * @returns The same content, sectioned.
+ */
+export declare function sectioned(html: string): string;
+//# sourceMappingURL=read-markdown.client.d.ts.map

package/dist/output-mapping/coerce-field.mapper.d.ts

@@ -0,0 +1,19 @@
+import type { FieldSpec } from '../recipe-schema/index.js';
+/** A value that cannot become the field's type. */
+export declare class CoercionError extends Error {
+    readonly path: string;
+    readonly name = "CoercionError";
+    constructor(path: string, reason: string);
+}
+/**
+ * Converts a transformed value into the field's declared type.
+ * `null` and `undefined` pass through: missing-value policies decide about them.
+ *
+ * @param value - The value after its transform chain.
+ * @param field - The output field.
+ * @param path - Where the field is, for messages.
+ * @returns The coerced value.
+ * @throws CoercionError when the conversion is impossible.
+ */
+export declare function coerceValue(value: unknown, field: FieldSpec, path: string): unknown;
+//# sourceMappingURL=coerce-field.mapper.d.ts.map

package/dist/output-mapping/generated-field.mapper.d.ts

@@ -0,0 +1,16 @@
+import type { GeneratedValue } from '../recipe-schema/index.js';
+/** What generated fields are produced from. */
+export interface GenerationSource {
+    recipeId: string;
+    url: string;
+    emittedAt: string;
+}
+/**
+ * The engine-supplied value of a generated field.
+ *
+ * @param kind - Which value.
+ * @param source - Where the record came from.
+ * @returns The value.
+ */
+export declare function generatedValue(kind: GeneratedValue, source: GenerationSource): unknown;
+//# sourceMappingURL=generated-field.mapper.d.ts.map

package/dist/output-mapping/index.d.ts

@@ -0,0 +1,9 @@
+export { mapRecord } from './map-record.use-case.js';
+export type { MapRecordRequest } from './map-record.use-case.js';
+export type { OutputRecord } from './output-record.model.js';
+export { recordKey } from './output-record.model.js';
+export { RecordRejectedError, MappingFailedError } from './mapping.error.js';
+export { coerceValue, CoercionError } from './coerce-field.mapper.js';
+export { validateField } from './output-field.validator.js';
+export { resolveMissingPolicy, isMissing } from './missing-value.policy.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/output-mapping/map-record.use-case.d.ts

@@ -0,0 +1,27 @@
+import type { HookRegistry } from '../hooks/index.js';
+import type { InputRecipe, OutputRecipe } from '../recipe-schema/index.js';
+import type { TransformContext } from '../transformation/index.js';
+import type { OutputRecord } from './output-record.model.js';
+/** Everything needed to turn one emitted scope snapshot into a record. */
+export interface MapRecordRequest {
+    snapshot: Record<string, unknown>;
+    input: InputRecipe;
+    output: OutputRecipe;
+    hooks: HookRegistry;
+    /** The page URL at emit time. */
+    url: string;
+    emittedAt?: string;
+    log?: TransformContext['log'];
+}
+/**
+ * Maps an emitted scope snapshot to a validated output record: resolves every
+ * mapping rule, runs its transform chain, fills generated fields, then coerces
+ * and validates each output field and applies the missing-value policy.
+ *
+ * @param request - The snapshot and the recipes.
+ * @returns The record.
+ * @throws RecordRejectedError when a field's policy is `skip-record`.
+ * @throws MappingFailedError when a field's policy is `fail`, or a transform throws.
+ */
+export declare function mapRecord(request: MapRecordRequest): Promise<OutputRecord>;
+//# sourceMappingURL=map-record.use-case.d.ts.map

package/dist/output-mapping/mapping.error.d.ts

@@ -0,0 +1,17 @@
+/** A record that does not satisfy its output recipe and is dropped (policy `skip-record`). */
+export declare class RecordRejectedError extends Error {
+    readonly field: string;
+    readonly reason: string;
+    readonly name = "RecordRejectedError";
+    constructor(field: string, reason: string);
+}
+/** A record that does not satisfy its output recipe under policy `fail`: the recipe stops. */
+export declare class MappingFailedError extends Error {
+    readonly field: string;
+    readonly reason: string;
+    readonly name = "MappingFailedError";
+    constructor(field: string, reason: string, options?: {
+        cause?: unknown;
+    });
+}
+//# sourceMappingURL=mapping.error.d.ts.map

package/dist/output-mapping/missing-value.policy.d.ts

@@ -0,0 +1,14 @@
+import type { FieldSpec, MappingRule, MissingPolicy, OutputRecipe } from '../recipe-schema/index.js';
+/** Whether a mapped value counts as missing. An empty list is a value. */
+export declare function isMissing(value: unknown): boolean;
+/**
+ * The policy for a missing value: mapping rule, then field, then recipe, then
+ * `default` when the field has one, `fail` when it is required, `null` otherwise.
+ *
+ * @param field - The output field.
+ * @param recipe - The output recipe.
+ * @param rule - The mapping rule that produced the value, if any.
+ * @returns The policy to apply.
+ */
+export declare function resolveMissingPolicy(field: FieldSpec, recipe: OutputRecipe, rule?: MappingRule): MissingPolicy;
+//# sourceMappingURL=missing-value.policy.d.ts.map

package/dist/output-mapping/output-field.validator.d.ts

@@ -0,0 +1,10 @@
+import type { FieldSpec } from '../recipe-schema/index.js';
+/**
+ * Checks a present, coerced value against the field's quality rules.
+ *
+ * @param value - A non-missing coerced value.
+ * @param field - The output field.
+ * @returns Every violated rule, as messages; empty when valid.
+ */
+export declare function validateField(value: unknown, field: FieldSpec): string[];
+//# sourceMappingURL=output-field.validator.d.ts.map

package/dist/output-mapping/output-record.model.d.ts

@@ -0,0 +1,20 @@
+/** One record a crawl produced, validated against its output recipe. */
+export interface OutputRecord {
+    data: Record<string, unknown>;
+    /** The identity from the output's `key` fields, `null` when the output declares none. */
+    key: string | null;
+    source: {
+        recipeId: string;
+        url: string;
+        emittedAt: string;
+    };
+}
+/**
+ * The identity of a record: its key field values, in output order, as one string.
+ *
+ * @param data - The validated record data.
+ * @param keyFields - The output fields marked `key`.
+ * @returns The key, or `null` when there are no key fields.
+ */
+export declare function recordKey(data: Record<string, unknown>, keyFields: readonly string[]): string | null;
+//# sourceMappingURL=output-record.model.d.ts.map

package/dist/pdf-document/index.d.ts

@@ -0,0 +1,7 @@
+export { readPdf, PdfReadError } from './read-pdf.client.js';
+export { pdfText, isPdfDocument } from './pdf-document.model.js';
+export type { PdfDocument, PdfPage, PdfRow, PdfCell, PositionedText } from './pdf-document.model.js';
+export { assembleRows, rowsOfCells } from './row-assembly.algorithm.js';
+export { findTables } from './pdf-table.algorithm.js';
+export type { PdfTable, TableQuery, TableAlign } from './pdf-table.algorithm.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/pdf-document/pdf-document.model.d.ts

@@ -0,0 +1,51 @@
+/** A run of text at a position on a page, in PDF points, y growing upwards from the bottom edge. */
+export interface PositionedText {
+    x: number;
+    /** The baseline. */
+    y: number;
+    width: number;
+    /** The font size: the text spans roughly `y` to `y + height`. */
+    height: number;
+    text: string;
+}
+/** One or more text runs that sit side by side on one baseline: a table cell, a label, a value. */
+export type PdfCell = PositionedText;
+/** Cells whose vertical extents overlap: one visual line, which in a table is one row. */
+export interface PdfRow {
+    /** The top of the highest cell. */
+    top: number;
+    /** The baseline of the lowest cell. */
+    bottom: number;
+    /** The cells, left to right. */
+    cells: PdfCell[];
+    /** The cells' texts joined by a tab, left to right. */
+    text: string;
+}
+export interface PdfPage {
+    number: number;
+    width: number;
+    height: number;
+    /** Top to bottom. Empty on a page with no text layer (a scan). */
+    rows: PdfRow[];
+}
+/** A PDF read into rows of positioned text: what `extract` works on. */
+export interface PdfDocument {
+    kind: 'pdf';
+    pages: PdfPage[];
+}
+/**
+ * The text a `regex` extract reads: one line per row (cells separated by a
+ * tab), pages separated by a blank line.
+ *
+ * @param document - The PDF.
+ * @returns The text.
+ */
+export declare function pdfText(document: PdfDocument): string;
+/**
+ * Whether a value bound in scope is a read PDF (so `extract … from` can take it).
+ *
+ * @param value - Anything.
+ * @returns Whether it is a {@link PdfDocument}.
+ */
+export declare function isPdfDocument(value: unknown): value is PdfDocument;
+//# sourceMappingURL=pdf-document.model.d.ts.map

package/dist/pdf-document/pdf-table.algorithm.d.ts

@@ -0,0 +1,43 @@
+import type { PdfDocument } from './pdf-document.model.js';
+/** What a table extract looks for. */
+export interface TableQuery {
+    /** Matches a table's header row, its cells joined by spaces (`^MODELLI`). */
+    header: RegExp;
+    /** Matches the row that ends a table (`^NOTA BENE`); a table also ends at the next header or the page's end. */
+    until?: RegExp;
+    /** Output key -> a pattern for the header cell of that column; unmatched columns are dropped. Without it, the header texts are the keys. */
+    columns?: Record<string, RegExp>;
+    /** How the table aligns a row's values against a cell wrapped over several lines; `auto` (the default) infers it. */
+    align?: TableAlign;
+}
+/** Where a row's values sit against a cell wrapped over several lines. */
+export type TableAlign = 'auto' | 'top' | 'center' | 'bottom';
+/** One table found in a PDF. */
+export interface PdfTable {
+    page: number;
+    /** The first header cell: the table's name when it has one (`MODELLI FIAT`). */
+    title: string;
+    /** The header cells, left to right. */
+    header: string[];
+    /** One object per row, keyed by column; a cell's lines are joined by spaces. */
+    rows: Record<string, string>[];
+}
+/**
+ * Finds every table whose header row matches, and reads its rows by column.
+ *
+ * Columns come from the body, not the header: a header is often centred over
+ * a column whose cells are left-aligned, so the header's position says little
+ * about where the column starts. The left edges of the body cells cluster into
+ * bands; each band belongs to the header cell that overlaps it most, or the
+ * nearest one when none does. A header spanning two columns reads both.
+ *
+ * A cell wrapped over several lines (a long name, a note, a list of versions)
+ * spreads one row over several lines, its values often centred beside it:
+ * the lines are regrouped into rows around the lines that carry values.
+ *
+ * @param document - The PDF.
+ * @param query - Which tables, and how to name their columns.
+ * @returns The tables, in page order.
+ */
+export declare function findTables(document: PdfDocument, query: TableQuery): PdfTable[];
+//# sourceMappingURL=pdf-table.algorithm.d.ts.map

package/dist/pdf-document/read-pdf.client.d.ts

@@ -0,0 +1,18 @@
+import type { PdfDocument } from './pdf-document.model.js';
+/** A PDF that cannot be read: not a PDF, encrypted, or with no text to read. */
+export declare class PdfReadError extends Error {
+    readonly name = "PdfReadError";
+}
+/**
+ * Reads a PDF's text layer into rows of positioned cells, with pdf.js. pdf.js
+ * is imported on first use, so recipes that never read a PDF never load it.
+ * Only text is read: no page is rendered, no script runs, no font is loaded.
+ *
+ * @param bytes - The file.
+ * @param source - Where it came from, for messages.
+ * @returns The document.
+ * @throws PdfReadError when the bytes are not a readable PDF, or no page has a
+ * text layer (a scan: OCR is not supported).
+ */
+export declare function readPdf(bytes: Uint8Array, source?: string): Promise<PdfDocument>;
+//# sourceMappingURL=read-pdf.client.d.ts.map

package/dist/pdf-document/row-assembly.algorithm.d.ts

@@ -0,0 +1,26 @@
+import type { PdfCell, PdfRow, PositionedText } from './pdf-document.model.js';
+/**
+ * Turns a page's text runs into rows of cells, top to bottom.
+ *
+ * Runs on one baseline that nearly touch become one cell. Cells whose vertical
+ * extents overlap become one row, even when their baselines differ: a table
+ * that centres its cells vertically puts a one-line value a few points above
+ * or below its two-line label, and a row built from equal baselines would pair
+ * the value with the wrong label.
+ *
+ * @param runs - The page's text runs, in any order.
+ * @returns The rows.
+ */
+export declare function assembleRows(runs: readonly PositionedText[]): PdfRow[];
+/**
+ * Groups finished cells into rows, top to bottom: cells whose vertical extents
+ * overlap share a row. For cells that need no joining, such as a slide's text
+ * boxes, each already a cell.
+ *
+ * @param cells - The cells, in any order.
+ * @returns The rows.
+ */
+export declare function rowsOfCells(cells: readonly PdfCell[]): PdfRow[];
+/** `Array#findLast`, which the es2022 library does not declare. */
+export declare function lastOf<T>(items: readonly T[], test: (item: T) => boolean): T | undefined;
+//# sourceMappingURL=row-assembly.algorithm.d.ts.map

package/dist/recipe-loading/index.d.ts

@@ -0,0 +1,9 @@
+export { loadRecipeSet, loadRecipes, bindRecipeSet } from './load-recipe-set.use-case.js';
+export type { RecipeSetSource } from './load-recipe-set.use-case.js';
+export { readRecipeSource } from './read-recipe-source.use-case.js';
+export type { RecipeSource, RecipeBytes, RecipeDocument } from './recipe-source.contract.js';
+export { RecipeSet } from './recipe-set.model.js';
+export { validateBinding, fieldAt } from './recipe-binding.validator.js';
+export { RecipeBindingError } from './recipe-binding.error.js';
+export type { BindingIssue } from './recipe-binding.error.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/recipe-loading/load-recipe-set.use-case.d.ts

@@ -0,0 +1,45 @@
+import type { InputRecipe, OutputRecipe } from '../recipe-schema/index.js';
+import type { RecipeSource } from './recipe-source.contract.js';
+import { RecipeSet } from './recipe-set.model.js';
+/** What to load, with the output recipe kept apart from the inputs. */
+export interface RecipeSetSource {
+    /** The output recipe, or a source holding exactly one output recipe among others. */
+    output: RecipeSource;
+    /**
+     * The input recipes. The output recipe itself is skipped when found here, so
+     * one directory or bundle holding both can be passed as both.
+     */
+    inputs: readonly RecipeSource[];
+}
+/**
+ * Loads, validates and binds one output recipe with its input recipes.
+ *
+ * @param source - Where the recipes are; each part takes any {@link RecipeSource}.
+ * @returns A bound set, inputs in the order given.
+ * @throws RecipeValidationError when a recipe does not match its contract.
+ * @throws RecipeBindingError when an input cannot feed the output.
+ */
+export declare function loadRecipeSet(source: RecipeSetSource): Promise<RecipeSet>;
+/**
+ * Loads, validates and binds recipes from one source holding all of them, the
+ * output recipe told apart from the inputs by its `kind`: a directory, a JSON
+ * Lines file or string, a `Blob` or `Buffer` of either, or an array of recipe
+ * objects.
+ *
+ * @param source - Where the recipes are.
+ * @returns A bound set, inputs in the order found.
+ * @throws Error when the source does not hold exactly one output recipe.
+ * @throws RecipeValidationError when a recipe does not match its contract.
+ * @throws RecipeBindingError when an input cannot feed the output.
+ */
+export declare function loadRecipes(source: RecipeSource): Promise<RecipeSet>;
+/**
+ * Binds already-parsed recipes into a set.
+ *
+ * @param output - The output recipe.
+ * @param inputs - The input recipes.
+ * @returns A bound set.
+ * @throws RecipeBindingError when an input cannot feed the output.
+ */
+export declare function bindRecipeSet(output: OutputRecipe, inputs: readonly InputRecipe[]): RecipeSet;
+//# sourceMappingURL=load-recipe-set.use-case.d.ts.map

package/dist/recipe-loading/read-recipe-source.use-case.d.ts

@@ -0,0 +1,14 @@
+import type { RecipeDocument, RecipeSource } from './recipe-source.contract.js';
+/**
+ * Reads recipes from any {@link RecipeSource}: paths, JSON or JSON Lines text,
+ * bytes, decoded objects, or an array mixing them. Nothing is validated yet;
+ * the documents keep where they came from, for error messages.
+ *
+ * @param source - Where the recipes are.
+ * @param label - What to call recipes that did not come from a file.
+ * @returns The decoded recipes, in the order given.
+ * @throws Error naming the source when a path is missing, text does not
+ * decode, or a value is not a recipe source at all.
+ */
+export declare function readRecipeSource(source: RecipeSource, label?: string): Promise<RecipeDocument[]>;
+//# sourceMappingURL=read-recipe-source.use-case.d.ts.map

package/dist/recipe-loading/recipe-binding.error.d.ts

@@ -0,0 +1,14 @@
+/** One problem in how an input recipe binds to its output recipe. */
+export interface BindingIssue {
+    recipeId: string;
+    /** Where in the input recipe: `mapping.price`, `steps.1.steps.0`, `session.bootstrap.steps.2`. */
+    path: string;
+    message: string;
+}
+/** An input recipe that parses but cannot feed its output recipe. */
+export declare class RecipeBindingError extends Error {
+    readonly issues: readonly BindingIssue[];
+    readonly name = "RecipeBindingError";
+    constructor(issues: readonly BindingIssue[]);
+}
+//# sourceMappingURL=recipe-binding.error.d.ts.map

package/dist/recipe-loading/recipe-binding.validator.d.ts

@@ -0,0 +1,34 @@
+import type { FieldSpec, InputRecipe, OutputRecipe } from '../recipe-schema/index.js';
+import type { BindingIssue } from './recipe-binding.error.js';
+/**
+ * Checks that an input recipe can actually feed its output recipe:
+ *
+ * - every mapping key names an output field (dotted for nested objects), and an
+ *   `each` rule targets an array of objects;
+ * - every `from` / `each` / `over` root is a step id bound anywhere in the
+ *   recipe, a `forEach` variable, a `paginate` `as` binding, or one of `page`,
+ *   `start`, `vars` (`emit` snapshots the whole scope chain, so any id can feed
+ *   the mapping);
+ * - every required output field is mapped, defaulted, or generated;
+ * - step ids are unique along any path;
+ * - web-only steps appear only in web recipes or inside a bootstrap, api-only
+ *   steps only in api recipes, and `next.selector` only in web mode;
+ * - exactly one emitting construct exists on any path (the two branches of an
+ *   `if` are separate paths);
+ * - a `captcha` step, and `onBlock.solve`, have a solver: their own or
+ *   `session.captcha.solver`.
+ *
+ * @param input - A parsed input recipe.
+ * @param output - The parsed output recipe it names.
+ * @returns Every problem found; empty when the recipes bind.
+ */
+export declare function validateBinding(input: InputRecipe, output: OutputRecipe): BindingIssue[];
+/**
+ * The output field at a dotted target, walking into `object` members.
+ *
+ * @param fields - The output recipe's fields.
+ * @param target - A mapping key.
+ * @returns The field, or `undefined`.
+ */
+export declare function fieldAt(fields: Record<string, FieldSpec>, target: string): FieldSpec | undefined;
+//# sourceMappingURL=recipe-binding.validator.d.ts.map

package/dist/recipe-loading/recipe-file.repository.d.ts

@@ -0,0 +1,11 @@
+import type { RecipeDocument } from './recipe-source.contract.js';
+/**
+ * Reads one recipe file, or every `.json` and `.jsonl` file directly inside a
+ * directory. A file holds one recipe, an array of them, or JSON Lines.
+ *
+ * @param location - A file or directory path.
+ * @returns The decoded recipes, files sorted by path.
+ * @throws When the path does not exist or a file is neither JSON nor JSON Lines.
+ */
+export declare function readRecipeFiles(location: string): Promise<RecipeDocument[]>;
+//# sourceMappingURL=recipe-file.repository.d.ts.map

package/dist/recipe-loading/recipe-set.model.d.ts

@@ -0,0 +1,12 @@
+import type { InputRecipe, OutputRecipe } from '../recipe-schema/index.js';
+/**
+ * One output recipe and the input recipes that feed it. The invariant that
+ * every input names this output is checked on construction; deeper binding
+ * rules live in the binding validator.
+ */
+export declare class RecipeSet {
+    readonly output: OutputRecipe;
+    readonly inputs: readonly InputRecipe[];
+    constructor(output: OutputRecipe, inputs: readonly InputRecipe[]);
+}
+//# sourceMappingURL=recipe-set.model.d.ts.map

package/dist/recipe-loading/recipe-source.contract.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Raw bytes holding recipe JSON or JSON Lines, UTF-8: a `Buffer` or any other
+ * typed array, an `ArrayBuffer`, a `Blob` or `File`, or a stream of chunks (a
+ * Node `Readable`, a web `ReadableStream`, any async iterable of bytes or text).
+ */
+export type RecipeBytes = Blob | ArrayBuffer | ArrayBufferView | AsyncIterable<Uint8Array | string>;
+/**
+ * Where recipes come from. Each form holds one recipe or many:
+ *
+ * - a string starting with `{` or `[` (after whitespace): JSON text (one recipe
+ *   or an array of them) or JSON Lines text (one recipe per line);
+ * - any other string: a path to a `.json` or `.jsonl` file, or a directory whose
+ *   `.json` and `.jsonl` files are read (sorted, not recursive);
+ * - {@link RecipeBytes}: the same text, still encoded;
+ * - an object: one recipe, already decoded;
+ * - an array: any mix of the above.
+ */
+export type RecipeSource = string | RecipeBytes | object | readonly RecipeSource[];
+/** One decoded recipe before validation, with where it came from. */
+export interface RecipeDocument {
+    /**
+     * A file path, `path:line` for a JSON Lines file, a `File`'s name, or a
+     * positional label (`recipes[2]`, `recipes:3`) for recipes that came from memory.
+     */
+    source: string;
+    content: unknown;
+}
+//# sourceMappingURL=recipe-source.contract.d.ts.map

package/dist/recipe-loading/recipe-text.mapper.d.ts

@@ -0,0 +1,14 @@
+import type { RecipeDocument } from './recipe-source.contract.js';
+/**
+ * Decodes recipe text: one JSON document (a recipe, or an array of recipes) or
+ * JSON Lines (one recipe per non-blank line).
+ *
+ * @param text - The text.
+ * @param label - Where it came from, prefixed to each document's source.
+ * @returns The decoded recipes: `label` for a single one, `label[i]` for array
+ * items, `label:line` for JSON Lines.
+ * @throws Error naming the label (and the line, for JSON Lines) when the text
+ * is neither.
+ */
+export declare function parseRecipeText(text: string, label: string): RecipeDocument[];
+//# sourceMappingURL=recipe-text.mapper.d.ts.map

package/dist/recipe-schema/index.d.ts

@@ -0,0 +1,15 @@
+export * from './recipe-kind.enum.js';
+export { fieldSpecSchema, outputRecipeSchema } from './output-recipe.contract.js';
+export type { FieldSpec, OutputRecipe } from './output-recipe.contract.js';
+export { stepSchema, errorPolicySchema, paginateNextSchema } from './step.contract.js';
+export type { Step, StepType, StepBaseFields, TargetFields, ErrorPolicy, PaginateNext, TakeKind, GotoStep, ClickStep, FillStep, PressStep, SelectStep, ScrollStep, WaitStep, EvaluateStep, ScreenshotStep, RequestStep, ExtractStep, SetStep, CollectStep, ForEachStep, IfStep, PaginateStep, EmitStep, HookStep, CaptchaStep, CaptchaCheck, } from './step.contract.js';
+export { transformRuleSchema, mappingRuleSchema } from './transform-rule.contract.js';
+export type { TransformRule, TransformOp, MappingRule, FromRule, EachRule } from './transform-rule.contract.js';
+export { inputRecipeSchema, sessionSpecSchema, startPointSchema, retryRuleSchema } from './input-recipe.contract.js';
+export type { InputRecipe, SessionSpec, SessionBootstrap, SessionAccess, BlockRule, BlockRotation, CaptchaSettings, RetryRule, StartPoint, CrawlLimits, RecipeCookie } from './input-recipe.contract.js';
+export { parseInputRecipe, parseOutputRecipe, recipeKindOf } from './recipe.validator.js';
+export { RecipeValidationError } from './recipe-validation.error.js';
+export type { RecipeIssue } from './recipe-validation.error.js';
+export { inputRecipeJsonSchema, outputRecipeJsonSchema } from './json-schema.mapper.js';
+export type { JsonSchemaDocument } from './json-schema.mapper.js';
+//# sourceMappingURL=index.d.ts.map