Recipes & Import

Import is a review workflow

ShoppyCat first looks for schema.org Recipe data embedded as JSON-LD. It can traverse graphs and instruction sections, collect ingredients, steps, images, yield, description, and tags, then present the result for review.

When structured data is missing, a bounded heuristic extracts likely ingredients and steps from visible page text. The fallback labels the result as raw extraction because uncertainty should remain visible.

One recipe, several useful actions

Create, edit, delete, search, and tag saved recipes
Scale ingredients by serving count
Attach cover and per-step images
Add ingredients to a selected shopping list
Add or consume ingredients from personal or household pantry
Estimate feasibility from current pantry state and common staples
Run a focused cooking session with step navigation and timers
Preserve remix ancestry for community recipes

Structured data before guessing

JSON-LD is machine-readable data embedded in a page. When a site declares that an object is a Recipe, ShoppyCat can read explicit ingredient and instruction fields instead of guessing from layout classes that may change next week.

ArcoBASICArcoBASIC communication example: choose an honest import path

' Import a recipe while preserving how certain the result is.
FUNCTION ImportRecipe(page)
    structured = FindJsonLdObject(page, "Recipe")

    ' Explicit recipe data is the strongest available source.
    IF structured <> NULL THEN
        RETURN {
            "Recipe": ParseStructuredRecipe(structured),
            "Source": "JSON-LD",
            "NeedsReview": FALSE
        }
    END IF

    ' Visible-text extraction is useful, but it is not equally certain.
    extracted = ExtractVisibleRecipeText(page)
    IF extracted <> NULL THEN
        RETURN {
            "Recipe": extracted,
            "Source": "HEURISTIC",
            "NeedsReview": TRUE
        }
    END IF

    RETURN {"Recipe": NULL, "Source": "NONE", "NeedsReview": TRUE}
END FUNCTION

Browser handoff

The companion Chrome and Edge extension looks for JSON-LD or recognizable ingredient lists, falls back to bounded DOM extraction, and hands the result to a ShoppyCat web review page. Visitors can save a recipe or send only the ingredients to a shopping list.

The extension does not pretend that arbitrary web pages are clean databases. Its job is to capture useful evidence and put a person in control of the final interpretation.

Trust the strongest available signal, and say so

JSON-LD parsing and the visible-text fallback are ShoppyCat's specific import mechanics. Another project will have a different hierarchy of sources: an API response versus a scraped page, a signed webhook versus a best-effort poll. The principle underneath the specific choice is what carries over.

The same hierarchy of trust shows up in log parsing, in ETL pipelines choosing between a structured export and a scraped report, and in any integration that ingests data the system does not control. Prefer the source that says what it means, and mark the source that only probably does.

ImportRecipe tries schema.org JSON-LD first because it is machine-readable and explicit, and only falls back to heuristic text extraction when that structured data is absent. Any system pulling from multiple sources of varying reliability should try the strongest signal first and treat weaker signals as fallback, not as equals.
The heuristic path sets NeedsReview to TRUE and labels its result as raw extraction, while the JSON-LD path does not. Surfacing a confidence flag on an inferred result, rather than presenting every result identically, is what lets a person know when to actually look closely.
The fallback extractor is described as bounded: it reads visible page text, not arbitrary layout guessing that could silently break when a site redesigns its markup. Any scraper or heuristic parser should have an explicit, narrow definition of what it is willing to infer, so failure looks like nothing found instead of a confident wrong answer.
The browser extension hands its result to a review page rather than saving directly. Any pipeline ingesting external, unowned data, a webhook payload, a user upload, a third-party API, benefits from a review step between extraction and commit, especially while the extraction logic is new.

LEARNING LAYER

Key terms, in plain language

You do not need a systems background to follow the work. These are the specialized terms used on this page.

JSON-LDJavaScript Object Notation for Linked Data: Structured machine-readable data embedded in a web page. Recipe sites often use it to label ingredients, instructions, yield, images, and other fields explicitly.
Repository boundary: An interface that describes domain operations while hiding where and how data is stored. Screens can request recipe or list behavior without becoming coupled to Firestore details.
Schema validation: Checking that proposed data has the expected fields, types, ownership, and limits before accepting it. This protects shared collections from malformed or overpowered writes.