One summarisation engine across web, backend and automation

Mapify could already make a map from an upload, a web page, or an automation such as Zapier. Those entry points were growing, and each one was close to owning its own prompts, its own save step and its own picture. The same document could then become a different tree on the website and in an automation.

The generator that should have been shared was not a function waiting to be called. Markdown conversion, saving, themes, prompts, the model client and the chat log were mixed through the open page. It reached into that page for the document, the on-screen viewer, the settings, the chat session, the local database and session storage, then fitted the map to the window. An automation has none of those. Pulling one piece out changed the layout of maps the website already showed. Each cut had to be put back together before the next one, or the product’s own generation broke. That extraction, and the repairs after it, ran from January into March.

Copying the generator into the backend would have made the drift permanent. A change to layout, markers or the markdown parser would have landed twice. The function had to move once, and the page-only pieces had to become arguments the caller fills in.

Moving the function was still not enough. A server has no browser canvas, so the picture has to be measured and painted another way. Two maps drawn at once ran the process out of memory. The backend also could not reach the website’s model and file routes until those became private, authenticated calls. Publishing the shared package, so the website and the backend imported one build, failed on package access, the container build and broken imports. The same stretch of work was the cleanup: page helpers renamed into plain arguments, files reorganised, and the paths that only made sense in a browser removed.

I extracted the generator into the shared package. A document, a web page, a transcript or an automation request is turned into one source first: the text, the language, who asked, and any attached media. The function then summarises that source, chooses the root topic, builds the tree and returns one result. The website passes the live page. The backend passes memory and a server canvas.

The model call stays on the web service. The backend asks Mapify’s private APIs for the language, the summary and the saved file, then turns the returned markdown into a document and a PNG. One generation runs at a time. An account that already has a map waiting is placed behind a new account, so one caller cannot fill the queue.

The website, the backend and automation produce the same tree, the same markdown and the same PNG. An automation can ask for that map when nobody has Mapify open. A new entry point collects the source. It does not rebuild summarisation, the hierarchy or the save step. One picture at a time keeps the server inside its memory, and a failure sits in the source step, the generation step, or the save step.

One mind-map engine is the source, the generator and the save step, shared by the page and by every caller that has no page. The empty stand-ins for the viewer, the window fit and the local database are the small part. The month is the extraction that must not change the website’s maps, the picture that has to be measured for real, the memory limit of painting it, and the publishing and cleanup that let both apps share one build.