Cartographer

Build **Cartographer**, an application that turns any subject — or any document a user uploads — into an infinitely explorable illustrated map. This is a complete, production-quality full-stack application — build every feature described below.

APP IDENTITY
App name: Cartographer. Tagline: "Type anything. Get an explorable illustrated map of it. Forever."
Icon: a sepia compass rose on aged parchment, flat and elegant, readable at 64px.

THE CORE EXPERIENCE
A user types "the French Revolution" and within seconds sees a hand-drawn antique territory map — regions, borders, rivers, a legend — where every region is a real sub-topic. They click "The Terror" and descend into an entirely new generated map of that. It never bottoms out. The descent is the product.

ENTITIES — create all eight with these exact fields
Map: id, title, subject, parent_map_id (nullable), depth (integer), summary (string), image_url, regions (array), created_by, view_count (integer, default 0), is_featured (boolean, default false), subject_hash (string, indexed)
Region: id, map_id, name, blurb (string, max 200 chars), region_type (enum: territory, landmark, river, frontier), x_pct (number 0-100), y_pct (number 0-100), size (enum: small, medium, large), child_map_id (nullable)
Expedition: id, user_email, map_path (array of map ids), started_at, depth_reached (integer)
SourceDoc: id, user_email, file_uri (private), original_filename, extracted_summary, resulting_map_id, uploaded_at
Annotation: map_id, user_email, region_id, note (string), created_at
Collection: id, user_email, name, map_ids (array), is_public (boolean)
Explorer: email, display_name, avatar_url, maps_created (integer), deepest_expedition (integer), title (string)
AuditLog: actor, action, entity, at

MAP GENERATION
Use InvokeLLM with add_context_from_internet set to true and a response_json_schema of:
{ summary: string, regions: [ { name: string, blurb: string, region_type: string, x_pct: number, y_pct: number, size: string } ] }
Requirements on the model: return between 6 and 10 regions. Coordinates must be geographically meaningful — closely related topics placed adjacent to each other, opposing or contradictory ideas placed on opposite coasts, foundational topics placed centrally. Every blurb must be written as an 18th-century explorer's field notes, in that voice, under 200 characters.

Use GenerateImage for the map artwork itself. Append this exact style suffix to every image prompt: "antique hand-drawn cartographic map, sepia and faded teal ink on aged parchment, hatched mountain ranges, decorative compass rose, no text, no lettering, no labels." The no-text instruction is critical — all labels come from the HTML overlay positioned at each region's x_pct and y_pct, never from the image.

INTEGRATIONS — use every one of these Base44 Core integrations, each for a real purpose
InvokeLLM — map structure generation with internet context and a strict response_json_schema, as specified above.
GenerateImage — the map artwork for every generated map.
ExtractDataFromUploadedFile — build the feature that makes this a tool rather than a toy: a user drops in a PDF, CSV, PNG, JPG or JPEG and the app maps that document. Upload a research paper and get its argument rendered as territory. Extract the document's structure into the same region schema, then generate the map from it.
UploadPrivateFile and CreateFileSignedUrl — uploaded source documents are stored privately and viewed only through a 300-second signed URL. The resulting map is public; the source document is not.
UploadFile — public storage for generated map images.
SendEmail — send an expedition summary when a registered user descends five or more levels in one session, and a weekly "new territories charted" digest.

BACKEND FUNCTIONS — create these three as Deno serverless functions
generate_map — orchestrates the LLM call, the image generation and the Region record writes. Must cache by subject_hash so a repeated subject returns instantly and costs nothing.
map_document — handles the upload-to-map pipeline end to end.
stitch_atlas — renders a user's entire expedition path as one downloadable poster image.

AUTOMATIONS — create these two scheduled automations
Daily: chart one new featured map from a rotating subject list, so the home page has changed every time someone returns.
Weekly: send the "new territories charted" digest to registered users.

AI AGENT
Build an in-app chat agent called "The Guide" with read access to the Map and Region records for whichever map the user is currently viewing. It answers questions about the territory the user is standing in, in the same explorer's voice, and can suggest which region is worth descending into next.

SCREENS
Atlas (home) — a single centred input reading "Map anything." Below it, featured maps as image cards with title and a depth badge. No login required to view or to create.
Map view — full-bleed generated map image. Region hotspots overlaid as absolutely positioned pins at their x_pct and y_pct. Hovering shows the blurb in a parchment tooltip. Clicking descends into that region's child map, generating it if it does not exist. A breadcrumb trail across the top shows the full expedition path, each crumb clickable to ascend.
Expedition log — the user's descent history as a vertical timeline with a "deepest expedition" statistic and a button to stitch it into a poster.
Collections — saved maps grouped into public or private collections.
System — see below.

THE SYSTEM PAGE (build this, it is not optional)
A page that renders this application's own architecture live: every entity with its real current record count, all seven Core integrations each with a green or amber status dot and the timestamp it last fired, the three backend functions, the two automations with their next scheduled run times, the AI agent, and the RBAC roles. Header text: "Built from one prompt." Show the totals prominently.

VISUAL DESIGN
Palette: parchment #F4E9D8, ink #2A2118, faded teal #3D6B6B, wax-seal red #8C3A2B. A serif display face for titles, a clean sans for UI chrome. Region pins fade in staggered by 60ms each. Descending into a child map uses a scale-and-crossfade transition, never a hard cut. The whole interface should feel like handling an old atlas.

SEED DATA — populate all of this on first run
Six fully pre-generated featured maps at depth 0: "The French Revolution", "How the Immune System Works", "Jazz", "The Deep Ocean", "The Roman Republic", "Consciousness". Each must have 8 regions with real coordinates and generated artwork, and each must have at least one child map already generated so a visitor can descend two levels with zero waiting.

GUARDRAILS
No login required to explore or to generate a map. Login only to save an expedition or a collection.
Cache every generated map by subject_hash — repeat lookups must be instant and free.
While generating, show an animated compass rose with rotating status lines such as "Surveying the coastline…", "Naming the frontier…", "Inking the borders…". Never show a bare spinner.
If the model returns fewer than 6 regions, retry once, then render whatever came back rather than failing.
Fully usable on a phone: pins become tappable, tooltips become a bottom sheet, breadcrumbs scroll horizontally.
Reject unsupported upload types with a clear message rather than failing silently. Supported: CSV, PNG, JPG, JPEG, PDF.

DONE MEANS
I land on the home page, click a featured map, click a region, arrive at a new generated map, and click back up the breadcrumb — all without logging in and without seeing a blank screen at any point. Uploading a PDF produces a map of that document. The System page proves the whole application came from one prompt.