tablefacts 0.1.0 → 0.3.0

package/types/lib/types.d.mts

@@ -253,7 +253,19 @@ export type ImportOptions = {
      */
     json?: string;
     /**
-     * Replace the whole menu, not only the categories in this import.
+     * This restaurant's table prefix (e.g. "makibar_"); empty for the unprefixed menu_* tables. Default "": importCluvi/importImageMenu fall back to the source config's.
+     */
+    tablePrefix?: string;
+    /**
+     * Write the unprefixed menu_* tables even when other restaurants' prefixed tables exist. Only for a single-restaurant database.
+     */
+    allowUnprefixed?: boolean;
+    /**
+     * Confirm a destructive `replaceAll`, which empties the target tables.
+     */
+    yes?: boolean;
+    /**
+     * Replace the whole menu, not only the categories in this import. Needs `yes`.
      */
     replaceAll?: boolean;
     /**
@@ -284,6 +296,7 @@ export type ImportResult = {
      */
     database: {
         label: string;
+        tables: string[];
         current: {
             categories: number;
             products: number;
@@ -297,6 +310,10 @@ export type ImportMenuOptions = ImportOptions & {
     title?: string;
 };
 export type CluviConfig = {
+    /**
+     * This restaurant's table prefix in a shared database (e.g. "cannario_"); empty for the unprefixed menu_* tables.
+     */
+    tablePrefix?: string;
     /**
      * Any page of the restaurant's Cluvi menu.
      */
@@ -315,6 +332,10 @@ export type CluviConfig = {
     sections?: Record<string, string>;
 };
 export type RawConfig = {
+    /**
+     * This restaurant's table prefix in a shared database (e.g. "mombasa_"); empty for the unprefixed menu_* tables.
+     */
+    tablePrefix?: string;
     /**
      * Page with the menu pictures, or a direct image URL.
      */
@@ -335,6 +356,10 @@ export type RawConfig = {
      * Multiplies every price. Default 1.
      */
     scale?: number;
+    /**
+     * Resolution a PDF page is rendered at before its product photos are screenshot. Default 2.
+     */
+    imageScale?: number;
     /**
      * Category that lists each group.
      */
@@ -372,7 +397,7 @@ export type CluviMenuOptions = {
 export type ImportCluviOptions = ImportOptions & CluviMenuOptions;
 export type ImageMenuReadOptions = {
     /**
-     * Pages or image URLs. Default: the config's url.
+     * Pages or image URLs, or PDF file paths/URLs. Default: the config's url.
      */
     urls?: string[];
     /**
@@ -396,6 +421,18 @@ export type ImageMenuReadOptions = {
      * Read the pages again instead of using the saved transcriptions.
      */
     refresh?: boolean;
+    /**
+     * Also save the dish photos printed on a PDF page here (resolved against projectDir). Enables photo extraction.
+     */
+    imageDir?: string;
+    /**
+     * https folder the saved photos will be published at; fills each product's image_url with it plus the file name.
+     */
+    imageBaseUrl?: string;
+    /**
+     * How photos are found: 'auto' (default) reads a PDF page from its text and matches placed photos by position, using the model's boxes only when the page has none; 'always' reads every PDF page as a picture so the model boxes every dish's photo. Default 'auto'.
+     */
+    imageBoxes?: 'auto' | 'always';
     /**
      * Default: the raw config.mjs.
      */
@@ -406,6 +443,10 @@ export type ListMenuImagesOptions = {
     urls?: string[];
     only?: string | number[];
     minWidth?: number;
+    /**
+     * Project folder. Default: TABLEFACTS_PROJECT or the current folder.
+     */
+    projectDir?: string;
     config?: RawConfig;
 };
 export type MenuImage = {
@@ -413,8 +454,19 @@ export type MenuImage = {
      * Position as the CLI's --list numbers it.
      */
     number: number;
+    /**
+     * The image URL, or "<pdf path or URL>#<page number>" for a PDF page.
+     */
     url: string;
     alt: string;
+    /**
+     * Where the page came from. Default: 'image'.
+     */
+    kind?: 'image' | 'pdf';
+    /**
+     * Characters of text a PDF page has (0 means it is a scan).
+     */
+    chars?: number;
 };
 export type PriceFormat = {
     /**
@@ -574,7 +626,10 @@ export type TablefactsErrorCode = 'EUSAGE' | 'ECONFIG' | 'EDEPENDENCY' | 'EFAILE
  * @typedef {object} ImportOptions
  * @property {boolean} [dryRun] Check and report, write nothing.
  * @property {string} [json] Also save the extracted menu as JSON at this path (resolved against projectDir).
- * @property {boolean} [replaceAll] Replace the whole menu, not only the categories in this import.
+ * @property {string} [tablePrefix] This restaurant's table prefix (e.g. "makibar_"); empty for the unprefixed menu_* tables. Default "": importCluvi/importImageMenu fall back to the source config's.
+ * @property {boolean} [allowUnprefixed] Write the unprefixed menu_* tables even when other restaurants' prefixed tables exist. Only for a single-restaurant database.
+ * @property {boolean} [yes] Confirm a destructive `replaceAll`, which empties the target tables.
+ * @property {boolean} [replaceAll] Replace the whole menu, not only the categories in this import. Needs `yes`.
  * @property {boolean} [force] Write even if the import has far fewer products than it replaces.
  * @property {string} [databaseUrl] Default: env.SUPABASE_DB_URL.
  * @property {Env} [env] Environment the database URL and keys are read from. Default process.env.
@@ -587,7 +642,7 @@ export type TablefactsErrorCode = 'EUSAGE' | 'ECONFIG' | 'EDEPENDENCY' | 'EFAILE
  * @property {string[]} notes
  * @property {boolean} written
  * @property {boolean} dryRun
- * @property {{ label: string, current: { categories: number, products: number, kept: string[] } } | null} database Null when the database was not reached.
+ * @property {{ label: string, tables: string[], current: { categories: number, products: number, kept: string[] } } | null} database Null when the database was not reached.
  */
 /**
  * @typedef {ImportOptions & { menu: Menu, notes?: string[], title?: string }} ImportMenuOptions
@@ -595,6 +650,7 @@ export type TablefactsErrorCode = 'EUSAGE' | 'ECONFIG' | 'EDEPENDENCY' | 'EFAILE
 /**
  * Restaurant-specific part of the Cluvi source (src/menu/cluvi/config.mjs).
  * @typedef {object} CluviConfig
+ * @property {string} [tablePrefix] This restaurant's table prefix in a shared database (e.g. "cannario_"); empty for the unprefixed menu_* tables.
  * @property {string} [url] Any page of the restaurant's Cluvi menu.
  * @property {{ slug: string, name: string, from: string[] }[]} [categories] Cluvi main categories folded into each site category.
  * @property {Record<string, string>} [sections] Cluvi subcategory to section name.
@@ -602,11 +658,13 @@ export type TablefactsErrorCode = 'EUSAGE' | 'ECONFIG' | 'EDEPENDENCY' | 'EFAILE
 /**
  * Restaurant-specific part of the picture-menu source (src/menu/raw/config.mjs).
  * @typedef {object} RawConfig
+ * @property {string} [tablePrefix] This restaurant's table prefix in a shared database (e.g. "mombasa_"); empty for the unprefixed menu_* tables.
  * @property {string} [url] Page with the menu pictures, or a direct image URL.
  * @property {string} currency ISO code of the prices.
  * @property {string} [thousands] Thousands separator the menu prints. Default ".".
  * @property {string} [decimal] Decimal separator the menu prints. Default ",".
  * @property {number} [scale] Multiplies every price. Default 1.
+ * @property {number} [imageScale] Resolution a PDF page is rendered at before its product photos are screenshot. Default 2.
  * @property {{ slug: string, name: string, groups?: ('food' | 'drink')[] }[]} [categories] Category that lists each group.
  * @property {Record<string, string>} [placeIn] Section title to category slug.
  * @property {Record<string, string>} [sections] Section title to the name stored.
@@ -623,13 +681,16 @@ export type TablefactsErrorCode = 'EUSAGE' | 'ECONFIG' | 'EDEPENDENCY' | 'EFAILE
 /** @typedef {ImportOptions & CluviMenuOptions} ImportCluviOptions */
 /**
  * @typedef {object} ImageMenuReadOptions
- * @property {string[]} [urls] Pages or image URLs. Default: the config's url.
+ * @property {string[]} [urls] Pages or image URLs, or PDF file paths/URLs. Default: the config's url.
  * @property {string | number[]} [only] Pages to read, e.g. '1,3-5' or [1, 3, 4, 5].
  * @property {string} [provider] Vision provider, see `providers`. Default MENU_VISION_PROVIDER or `defaultProvider`.
  * @property {string} [model]
  * @property {number} [minWidth] Ignore images declaring a smaller width. Default 500.
  * @property {string} [apiKey] Default: the provider's key in env.
  * @property {boolean} [refresh] Read the pages again instead of using the saved transcriptions.
+ * @property {string} [imageDir] Also save the dish photos printed on a PDF page here (resolved against projectDir). Enables photo extraction.
+ * @property {string} [imageBaseUrl] https folder the saved photos will be published at; fills each product's image_url with it plus the file name.
+ * @property {'auto' | 'always'} [imageBoxes] How photos are found: 'auto' (default) reads a PDF page from its text and matches placed photos by position, using the model's boxes only when the page has none; 'always' reads every PDF page as a picture so the model boxes every dish's photo. Default 'auto'.
  * @property {RawConfig} [config] Default: the raw config.mjs.
  */
 /** @typedef {ImportOptions & ImageMenuReadOptions} ImportImageMenuOptions */
@@ -638,13 +699,16 @@ export type TablefactsErrorCode = 'EUSAGE' | 'ECONFIG' | 'EDEPENDENCY' | 'EFAILE
  * @property {string[]} [urls]
  * @property {string | number[]} [only]
  * @property {number} [minWidth]
+ * @property {string} [projectDir] Project folder. Default: TABLEFACTS_PROJECT or the current folder.
  * @property {RawConfig} [config]
  */
 /**
  * @typedef {object} MenuImage
  * @property {number} number Position as the CLI's --list numbers it.
- * @property {string} url
+ * @property {string} url The image URL, or "<pdf path or URL>#<page number>" for a PDF page.
  * @property {string} alt
+ * @property {'image' | 'pdf'} [kind] Where the page came from. Default: 'image'.
+ * @property {number} [chars] Characters of text a PDF page has (0 means it is a scan).
  */
 /**
  * @typedef {object} PriceFormat

package/types/menu/cluvi/config.d.mts

@@ -1,4 +1,5 @@
 declare const _default: {
+    tablePrefix: string;
     url: string;
     categories: {
         slug: string;

package/types/menu/cluvi/import.d.mts

@@ -4,6 +4,7 @@
  */
 export declare function fetchCluviMenu({ url, service, lang, config }?: {
     config?: {
+        tablePrefix: string;
         url: string;
         categories: {
             slug: string;
@@ -26,6 +27,7 @@ export declare function fetchCluviMenu({ url, service, lang, config }?: {
     }[];
     notes: string[];
     title: string;
+    tablePrefix: string;
 }>;
 /**
  * Reads the menu from Cluvi and imports it. Takes importMenu's options too.

package/types/menu/lib/db.d.mts

@@ -3,19 +3,47 @@ export declare function connect(url: any, { env }?: {}): Promise<{
     client: any;
     label: string;
 }>;
+/**
+ * Refuses to touch another site's tables before anything is written.
+ *
+ * Checks the three target tables exist (pointing at the migration when they do not). Then, when
+ * no prefix is set, lists the other restaurants' `<prefix>_menu_categories` tables: any of them
+ * means this database is shared, so the import stops unless the caller confirmed it targets the
+ * one unprefixed set with `allowUnprefixed`. A whole-menu `replaceAll` is refused in that case
+ * whatever the flags say, because deleting every unprefixed row could destroy another site.
+ * Only reads; returns `{ prefix, tables, others }`.
+ * @param {any} client
+ * @param {{ tablePrefix?: string, allowUnprefixed?: boolean, replaceAll?: boolean }} [options]
+ */
+export declare function assertTarget(client: any, { tablePrefix, allowUnprefixed, replaceAll }?: {
+    tablePrefix?: string;
+    allowUnprefixed?: boolean;
+    replaceAll?: boolean;
+}): Promise<{
+    prefix: string;
+    tables: {
+        categories: string;
+        sections: string;
+        products: string;
+    };
+    others: any;
+}>;
 /** What an import would replace: the categories it writes, or the whole menu. */
-export declare function inspect(client: any, menu: any, { replaceAll }?: {
+export declare function inspect(client: any, menu: any, { replaceAll, tablePrefix }?: {
     replaceAll?: boolean | undefined;
+    tablePrefix?: string | undefined;
 }): Promise<any>;
 /**
  * Replaces the menu in one transaction, so readers see the old menu or the new
  * one and a failure changes nothing. By default only the categories in `menu`
  * are replaced (deleting a category cascades to its sections and products);
  * `replaceAll` empties the menu first. Ids are generated here so the rows can
- * be inserted in bulk, a column at a time.
+ * be inserted in bulk, a column at a time. `tablePrefix` is the restaurant's
+ * own table set; the delete is scoped to it, never to another site's tables.
  */
-export declare function replaceMenu(client: any, menu: any, { replaceAll }?: {
+export declare function replaceMenu(client: any, menu: any, { replaceAll, tablePrefix }?: {
     replaceAll?: boolean | undefined;
+    tablePrefix?: string | undefined;
 }): Promise<{
     categories: any;
     sections: any;

package/types/menu/lib/import.d.mts

@@ -8,4 +8,4 @@ export declare function templateHints(menu: any, { projectDir }?: {}): Promise<s
  * @param {import('../../lib/types.mjs').ImportMenuOptions} options
  * @returns {Promise<import('../../lib/types.mjs').ImportResult>}
  */
-export declare function importMenu({ menu, notes, title, dryRun, json, replaceAll, force, databaseUrl, env, projectDir, log: logOption, }?: import('../../lib/types.mjs').ImportMenuOptions): Promise<import('../../lib/types.mjs').ImportResult>;
+export declare function importMenu({ menu, notes, title, dryRun, json, replaceAll, force, tablePrefix, allowUnprefixed, yes, databaseUrl, env, projectDir, log: logOption, }?: import('../../lib/types.mjs').ImportMenuOptions): Promise<import('../../lib/types.mjs').ImportResult>;

package/types/menu/lib/run.d.mts

@@ -4,6 +4,12 @@ export declare const menuFlags: {
     provider: string;
     model: string;
     minWidth: string;
+    imageDir: string;
+    imageBaseUrl: string;
+    imageBoxes: string;
+    tablePrefix: string;
+    allowUnprefixed: string;
+    yes: string;
     replaceAll: string;
     force: string;
     dryRun: string;

package/types/menu/lib/tables.d.mts

@@ -0,0 +1,18 @@
+/**
+ * `tablePrefix` when it is empty or a safe `<name>_` prefix (an ECONFIG error otherwise).
+ * @param {string} [tablePrefix]
+ * @returns {string}
+ */
+export declare function validateTablePrefix(tablePrefix?: string): string;
+/**
+ * The three `public` menu tables for a prefix, e.g.
+ * `{ categories: "public.makibar_menu_categories", sections: "public.makibar_menu_sections", products: "public.makibar_menu_products" }`.
+ * The default (empty prefix) is the unprefixed `public.menu_*` set.
+ * @param {string} [tablePrefix]
+ * @returns {{ categories: string, sections: string, products: string }}
+ */
+export declare function menuTables(tablePrefix?: string): {
+    categories: string;
+    sections: string;
+    products: string;
+};

package/types/menu/raw/config.d.mts

@@ -1,9 +1,11 @@
 declare const _default: {
+    tablePrefix: string;
     url: string;
     currency: string;
     thousands: string;
     decimal: string;
     scale: number;
+    imageScale: number;
     categories: {
         slug: string;
         name: string;

package/types/menu/raw/images.d.mts

@@ -0,0 +1,27 @@
+/**
+ * The page's text item that best matches `name`: an exact match first, then a
+ * line that contains it (preferring the shortest such line). null when no line
+ * holds the name, which happens when a heading was drawn as an outline.
+ */
+export declare function findNameItem(items: any, name: any): any;
+/**
+ * One crop per product, in page order. `pages` maps a page number to
+ * `{ width, items, placed, direct }` (see the file comment). A crop is used
+ * once, so a single photo between two items goes to the closer one. Returns
+ * `{ matches, notes }`; matches carry the placement and the crop it won.
+ * @param {{ page: number, name: string, box: number[] | null, products: any[] }[]} placements
+ * @param {Map<number, any>} pages
+ * @returns {{ matches: { placement: any, crop: any }[], notes: string[] }}
+ */
+export declare function matchPlacements(placements: {
+    page: number;
+    name: string;
+    box: number[] | null;
+    products: any[];
+}[], pages: Map<number, any>): {
+    matches: {
+        placement: any;
+        crop: any;
+    }[];
+    notes: string[];
+};

package/types/menu/raw/import.d.mts

@@ -1,11 +1,17 @@
-/** Every image found, and the numbered ones `only` selects. `config` defaults to config.mjs. */
-export declare function findPages({ urls, only, minWidth, config }?: {
+/**
+ * Every page found, and the numbered ones `only` selects. A PDF argument
+ * contributes one page per PDF page; anything else is scanned for menu pictures.
+ * `close()` releases the open PDFs.
+ */
+export declare function findPages({ urls, only, minWidth, projectDir, config }?: {
     config?: {
+        tablePrefix: string;
         url: string;
         currency: string;
         thousands: string;
         decimal: string;
         scale: number;
+        imageScale: number;
         categories: {
             slug: string;
             name: string;
@@ -20,23 +26,44 @@ export declare function findPages({ urls, only, minWidth, config }?: {
     minWidth?: number | undefined;
     urls?: never[] | undefined;
 }): Promise<{
-    pages: any[];
-    chosen: any[];
+    pages: {
+        kind: string;
+        source: any;
+        host: string;
+        label: string;
+        pageNumber: number;
+        url: string;
+        chars: number;
+        number: number;
+    }[];
+    chosen: {
+        kind: string;
+        source: any;
+        host: string;
+        label: string;
+        pageNumber: number;
+        url: string;
+        chars: number;
+        number: number;
+    }[];
+    close: () => Promise<void>;
 }>;
 /**
- * The pictures the CLI's `--list` prints, numbered. `only` narrows them.
+ * The pages `--list` prints, numbered, including PDF pages with their text size.
  * @param {import('../../lib/types.mjs').ListMenuImagesOptions} [options]
  * @returns {Promise<import('../../lib/types.mjs').MenuImage[]>}
  */
 export declare function listMenuImages(options?: import('../../lib/types.mjs').ListMenuImagesOptions): Promise<import('../../lib/types.mjs').MenuImage[]>;
 /** Reads the pages and normalizes them: `{ menu, notes, title }`, ready for importMenu. */
-export declare function fetchImageMenu({ urls, only, provider, model, minWidth, refresh, apiKey, env, projectDir, config, log: logOption }?: {
+export declare function fetchImageMenu({ urls, only, provider, model, minWidth, refresh, apiKey, env, projectDir, config, imageDir, imageBaseUrl, imageBoxes, log: logOption }?: {
     config?: {
+        tablePrefix: string;
         url: string;
         currency: string;
         thousands: string;
         decimal: string;
         scale: number;
+        imageScale: number;
         categories: {
             slug: string;
             name: string;
@@ -48,6 +75,7 @@ export declare function fetchImageMenu({ urls, only, provider, model, minWidth,
         };
         skipSections: never[];
     } | undefined;
+    imageBoxes?: string | undefined;
     minWidth?: number | undefined;
     refresh?: boolean | undefined;
     urls?: never[] | undefined;
@@ -55,9 +83,10 @@ export declare function fetchImageMenu({ urls, only, provider, model, minWidth,
     menu: import("../../lib/types.mjs").Menu;
     notes: string[];
     title: string;
+    tablePrefix: string;
 }>;
 /**
- * Reads the menu from pictures with a vision model and imports it. Takes importMenu's options too.
+ * Reads the menu from pictures or a PDF and imports it. Takes importMenu's options too.
  * @param {import('../../lib/types.mjs').ImportImageMenuOptions} [options]
  * @returns {Promise<import('../../lib/types.mjs').ImportResult>}
  */

package/types/menu/raw/normalize.d.mts

@@ -16,7 +16,7 @@ export declare function parsePrice(text: string, { thousands, decimal, scale }?:
  * product per column, "Name (Botella)", because a product has one price.
  * @param {{ number?: number, notes?: string[], sections?: any[] }[]} pages transcriptions, one per page
  * @param {import('../../lib/types.mjs').RawConfig} config
- * @returns {{ menu: import('../../lib/types.mjs').Menu, notes: string[], currency: string }}
+ * @returns {{ menu: import('../../lib/types.mjs').Menu, notes: string[], currency: string, placements: { page: number, name: string, box: number[] | null, products: import('../../lib/types.mjs').MenuProduct[] }[] }}
  */
 export declare function normalizePages(pages: {
     number?: number;
@@ -26,4 +26,10 @@ export declare function normalizePages(pages: {
     menu: import('../../lib/types.mjs').Menu;
     notes: string[];
     currency: string;
+    placements: {
+        page: number;
+        name: string;
+        box: number[] | null;
+        products: import('../../lib/types.mjs').MenuProduct[];
+    }[];
 };

package/types/menu/raw/pdf.d.mts

@@ -0,0 +1,98 @@
+/**
+ * True when an argument names a PDF: a local file ending in .pdf, or a URL whose
+ * path ends in .pdf. A URL that hides the extension comes back from the fetch as
+ * an HTML page with no pictures, and the reader says to pass the file instead.
+ * @param {string} input
+ * @returns {boolean}
+ */
+export declare function isPdfInput(input: string): boolean;
+/**
+ * The PDF's bytes, from a local file (`projectDir`-relative) or an http(s) URL.
+ * `host` names the cache folder, `label` is what a note calls the file.
+ * @param {string} input
+ * @param {{ projectDir?: string }} [options]
+ * @returns {Promise<{ bytes: Uint8Array, host: string, label: string }>}
+ */
+export declare function readPdfSource(input: string, { projectDir }?: {
+    projectDir?: string;
+}): Promise<{
+    bytes: Uint8Array;
+    host: string;
+    label: string;
+}>;
+/**
+ * Opens a PDF for reading. `close()` releases pdfjs's worker; call it when the
+ * run is done with the file. `textCache` keeps a page's text from being read twice.
+ * @param {Uint8Array} bytes
+ * @returns {Promise<any>} the open document handle
+ */
+export declare function openPdf(bytes: Uint8Array): Promise<any>;
+/**
+ * One page's text and its pieces. `items` are pdfjs's text items, kept for
+ * matching a product name to a spot on the page when placing product photos.
+ * @returns {Promise<{ page: any, text: string, items: any[] }>}
+ */
+export declare function readPdfText(source: any, number: any): Promise<{
+    page: any;
+    text: string;
+    items: any[];
+}>;
+/** Every page that has text worth transcribing, and how much. Used by `--list`. */
+export declare function inspectPdf(source: any): Promise<{
+    number: number;
+    hasText: boolean;
+    chars: number;
+}[]>;
+/**
+ * The text items flattened to `{ str, x, y, width, height }`, which both the
+ * text builder and the product-photo matcher understand.
+ */
+export declare const positionedItems: (items: any) => any;
+/**
+ * Rebuilds readable text from pdfjs text items: pieces on the same line are
+ * joined in reading order, a wide vertical gap becomes a blank line so the model
+ * still sees section breaks. A page with two clear columns is read column by
+ * column, so the two columns' rows are not merged. Pure, so it is tested without
+ * a PDF.
+ * @param {{ str?: string, transform?: number[], width?: number, height?: number }[]} items
+ * @returns {string}
+ */
+export declare function textFromItems(items: {
+    str?: string;
+    transform?: number[];
+    width?: number;
+    height?: number;
+}[]): string;
+/** A page's rendered pixels, the context, and the viewport they were rendered with. */
+export declare function renderPdfPage(source: any, page: any, { scale, recordImages }?: {
+    recordImages?: boolean | undefined;
+    scale?: number | undefined;
+}): Promise<{
+    canvas: any;
+    context: any;
+    viewport: any;
+    scale: number;
+}>;
+/** Releases a rendered canvas's native memory. */
+export declare function destroyPage(source: any, { canvas, context }?: {}): void;
+/**
+ * The rectangle each image occupies on a page render. pdfjs records this itself
+ * when rendering with `recordImages` (three points per image, fractions of the
+ * canvas, top-left origin): it is clip- and group-aware, unlike walking the
+ * operator list by hand.
+ */
+export declare function imageRects(canvas: any, coordinates: any): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}[];
+/** Crops a pixel rectangle out of a page render, as a PNG buffer. */
+export declare function cropPdfPixels(source: any, canvas: any, { x, y, width, height }: {
+    height: any;
+    width: any;
+    x: any;
+    y: any;
+}, { padding }?: {
+    padding?: number | undefined;
+}): any;

package/types/menu/raw/pdfjs.d.mts

@@ -0,0 +1,12 @@
+/**
+ * The pdfjs module plus the asset URLs it needs (standard fonts and CMaps) so
+ * text is extracted and pages render without the warnings Node otherwise logs.
+ * @returns {Promise<{ pdfjs: any, standardFontDataUrl: string, cMapUrl: string }>}
+ */
+export declare function loadPdfjs(): Promise<{
+    pdfjs: any;
+    standardFontDataUrl: string;
+    cMapUrl: string;
+}>;
+/** A rendering failure caused by the canvas package being absent becomes EDEPENDENCY with the install hint. */
+export declare function renderError(error: any): any;

package/types/menu/raw/source.d.mts

@@ -1,3 +1,5 @@
+/** A fetch with retries on server errors; shared with the PDF reader. */
+export declare function get(url: any, what: any): Promise<Response>;
 /**
  * The picture URLs of a page, in document order. Lazy-loaders keep the real
  * address in data-orig-src / data-src and put a placeholder in src, so those

package/types/menu/raw/vision.d.mts

@@ -1,10 +1,20 @@
 /** @type {Record<string, import('../../lib/types.mjs').VisionProvider>} */
 export declare const providers: Record<string, import('../../lib/types.mjs').VisionProvider>;
 export declare const defaultProvider = "anthropic";
-/** `file` is a downloaded picture; returns `{ sections, notes }` as the schema above describes. */
+/** `file` is a downloaded picture; returns `{ sections, notes }` as the schema above describes. `boxes` also asks for each item's printed photo rectangle. */
 export declare function readPage({ file, mediaType }: {
     file: any;
     mediaType: any;
+}, { provider, model, apiKey, env, boxes }?: {
+    boxes?: boolean | undefined;
+    provider?: string | undefined;
+}): Promise<{
+    sections: any;
+    notes: any;
+}>;
+/** `text` is one page's extracted text; returns the same `{ sections, notes }` the picture path does. */
+export declare function readText({ text }: {
+    text: any;
 }, { provider, model, apiKey, env }?: {
     provider?: string | undefined;
 }): Promise<{

package/types/research/lib/merge.d.mts

@@ -1,9 +1,10 @@
-export declare function buildProfile({ query, google, osm, site, hub, instagram, tripadvisor }: {
+export declare function buildProfile({ query, google, osm, site, hub, instagram, tripadvisor, search }: {
     google: any;
     hub: any;
     instagram: any;
     osm: any;
     query: any;
+    search: any;
     site: any;
     tripadvisor: any;
 }): {
@@ -82,6 +83,8 @@ export declare function buildProfile({ query, google, osm, site, hub, instagram,
             followers: any;
             posts: any;
             blocked: any;
+            partial: any;
+            surface: any;
         } | null;
     };
 };

package/types/research/lib/report.d.mts

@@ -1,4 +1,17 @@
-export declare function renderReport(p: any, { notes, photos }: {
+/**
+ * Splits the fields into what was discovered from a source, what was only echoed
+ * back from the user's own input, and low-confidence guesses, so a summary can
+ * say "N facts, M from your input" instead of counting all of them as found.
+ */
+export declare function fieldSummary(p: any): {
+    discovered: string[];
+    echoed: string[];
+    guessed: string[];
+};
+/** The CLI summary: what came from a source, what was only echoed, what was a low guess. */
+export declare function summaryLines(p: any): string[];
+export declare function renderReport(p: any, { notes, photos, kept }: {
+    kept?: never[] | undefined;
     notes: any;
     photos: any;
 }): string;