content formats

How EduGenius's Plugins Feature Clips Content Into a Lesson — But Not Into the Export

EduGenius Team··18 min read

Watch the EduGenius tutorials playlist

Feature walkthroughs, setup help, and practical learning workflows connected to this article.

Open Tutorials

How EduGenius's Plugins Feature Clips Content Into a Lesson — But Not Into the Export

Plugins is EduGenius's real, working pipeline for saving something you clipped while browsing — a passage of text or an image — and inserting it into a lesson you're editing inside the app. It's fully wired end to end: clipping, storage, browsing, deleting, and inserting all work today, with no credit or plan gating attached.

The one thing it does not do, and the reason this piece exists, is carry that inserted clip into any exported file. A diagram you insert while drafting shows up on screen and survives a reload — but export a PDF, Word doc, PowerPoint, or any of EduGenius's other file formats, and the clip is gone.

Quick Answer: Plugins saves a clipped text passage (up to 20,000 characters) or image (up to 5MB, JPEG/PNG/GIF/WebP) to a private, per-teacher pool — POST /api/plugins/clip or POST /api/plugins/media, rate-limited to 60 text clips and 30 image clips per hour. Clips are browsable and deletable at Library → Plugins, and insertable into any piece of generated content you're editing through an "Insert media" button that opens a picker modal. Access requires only a verified, logged-in account — no plan tier, no credits. The honest limit: an inserted clip lives in a pluginMedia field on the content session, and none of EduGenius's seven export formats — HTML, Word, PowerPoint, Text, PDF, TeX, or JSON — read that field. Verified directly against lib/content-export.js and the JSON exporter: pluginMedia doesn't appear anywhere in the export code path.

This piece walks through what Plugins actually is end to end — how a clip gets saved, how you find it again, how you insert it into a lesson, and exactly what happens (and doesn't) when you export that lesson afterward. It's a mechanics piece, not a workflow tutorial with quiz types or distractor design — Plugins isn't a content-generation format, it's the connective layer that gets outside material into one.

What Plugins Actually Is (and Isn't)

Plugins is the app-side half of a two-part pipeline. The other half — the browser extension itself, and how a teacher selects and sends a clip in the first place — is covered in its own piece. This article picks up from the moment a clip already exists in your pool: how you browse it, manage it, and use it.

Two Ends of One Pipeline

Think of it as a save point in the middle of a longer workflow:

  • Clip (extension, on any webpage) → saved to your personal Plugins pool
  • Browse and manage (/library/plugins, in the app) → see everything you've clipped, delete what you don't need
  • Insert (while editing a generated lesson) → pull a saved clip into the content you're actively working on

Each step is real and independently useful. A clip doesn't have to be inserted into anything to be worth keeping — the pool itself is a legitimate reference library.

Not the Same as "Turn Selection Into Practice"

The extension has a separate shortcut worth distinguishing from Plugins: selecting text and turning it directly into a practice quiz or worksheet, skipping the clip-and-insert step entirely. Plugins is the opposite motion — it saves the original material as-is, so you can reference or attach it to content you generate or edit later, rather than transforming it immediately.

If you want the selection to become a new quiz right away, that's the extension's direct-to-generation shortcut. If you want to hang onto the original diagram or passage and drop it into something you're already building, that's Plugins.

How a Clip Gets Into the Plugins Pool

Clipping is handled by two separate API routes depending on what you selected, and both apply real, server-enforced limits rather than accepting anything unbounded.

Text Clips: Cleaned and Capped

A clipped passage goes to POST /api/plugins/clip, where the server sanitizes it before anything is written to the database: control characters stripped, whitespace collapsed, and the whole thing capped at 20,000 characters — long past what a reference passage would ever need.

The result is stored as plain text, not interpreted HTML. Every place that later displays a text clip — the library page, the insert picker, the "Inserted media" panel — renders it as plain text on screen, so nothing about a clipped passage ever executes as markup.

Image Clips: Capped at 5MB, Four Formats Only

An image clip goes to POST /api/plugins/media as base64-encoded data. The server checks the declared content type against an allow-list — JPEG, PNG, GIF, or WebP only — before decoding anything, and rejects the upload if the decoded buffer is empty or exceeds 5MB. Accepted images go to Cloud Storage under a path scoped to your account; only a short-lived signed URL is ever handed back to the browser.

The Rate Limits, and Why They Exist

Both clip endpoints are rate-limited per account, not just per request:

Clip typeSize capStorageRate limit
Text20,000 charactersFirestore document (users/{uid}/plugins/{id})60 clips per hour
Image5MBCloud Storage + Firestore metadata doc30 clips per hour

Neither limit is a number a normal browsing-and-clipping session would bump into — they exist to bound abuse, not to ration a teacher's actual workflow.

Browsing, Managing, and Deleting What You've Clipped

Everything you've clipped lands in one place inside the app, reachable from the Library navigation tab.

The Library → Plugins Page

/library/plugins lists your saved clips, newest first, pulled from GET /api/plugins — capped at your 200 most recent. Each card shows the clip (image or text preview), its title, and, when a clip has one, a link back to the page it came from.

If you haven't clipped anything yet, the page says so plainly rather than showing a blank grid: install the extension, select something on a page, and choose "Clip selection → Plugins."

Delete Removes Both the Record and the File

Deleting a clip is real and permanent, not a soft archive. DELETE /api/plugins/[id] is scoped to clips you own — ownership is enforced by the Firestore path itself, users/{uid}/plugins/{id} — and for an image clip it removes the Cloud Storage object along with the Firestore document, so nothing orphaned is left behind.

Inserting a Clip Into a Lesson You're Editing

This is the step that turns a saved clip from a personal reference item into part of a specific piece of generated content.

Where "Insert Media" Actually Lives

While you're viewing or editing a piece of generated content — a worksheet, a quiz, a lesson plan, almost any format — an "Insert media" button sits next to the export controls. Clicking it opens a picker modal that loads your Plugins pool and lets you choose any clip, text or image, with a single click.

The button only appears once the content you're viewing already has a saved session behind it. You're inserting into something that exists, not into a draft that hasn't been generated yet.

What Happens After You Insert

Picking a clip appends it to that content's pluginMedia array — a list separate from the generated question or lesson body itself — and the update is written back to the content session immediately through the same API route used for other inline edits. The clip then appears on screen under an "Inserted media" section, and because the write went to the actual stored session document, the entry itself is still there the next time you open that content, not just for the rest of the current browser tab.

A teacher researching a lesson on plate tectonics, say, could clip a cross-section diagram while reading a reference site, then insert that same diagram into the worksheet they're drafting a few minutes later — without downloading the image, re-uploading it anywhere, or losing the source link.

There's a narrower wrinkle worth naming alongside the export gap, specific to inserted images. The image URL captured into pluginMedia at insert time is a signed Cloud Storage link with a one-hour expiry, minted once when the picker loads — nothing re-signs it afterward.

In practice, an inserted image's thumbnail can go stale roughly an hour after insertion, showing broken on a later reload even though the pluginMedia entry — title, source link, record of insertion — is still there. The image itself is unaffected: it's permanent in Cloud Storage, and your Plugins library always renders it correctly, since that page mints a fresh link every time you open it. Text clips aren't affected — they're stored and displayed as literal text, with no expiring link involved.

The Honest Limitation: Insert Media Never Reaches the Export

Here's the part worth stating plainly: an inserted clip is real, visible, and persistent inside the app — and it stops there. Export the same content, and the clip is absent from the file you get back.

Why a Teacher Might Not Notice Right Away

The "Inserted media" section renders directly above or alongside the generated content in the editing view, so a clipped diagram looks, at a glance, like a normal part of the material. It's easy to assume something that visually integrated will travel with the rest of the content when you export it — nothing in the editing screen signals otherwise.

What the Export Code Actually Does

Every export format runs through one shared entry point in lib/content-export.js. Before any format-specific formatter runs, a helper function called extractContentData pulls the piece of the content object that actually gets exported — and it only ever looks at content.content.data, content.content, or content.data, depending on shape. pluginMedia sits in none of those.

Checking one exporter concretely makes the gap easiest to see. lib/export/exporters/json.js builds its output payload from a metadata block (title, format ID, export timestamp, whether answers are included) and a formattedContent block (title, content, optional matching-question metadata) — no pluginMedia key anywhere. JSON export is the likeliest format to expose a stray internal field, since it serializes the underlying data structure directly instead of rendering it into a document first.

A repository-wide search for pluginMedia turns up exactly two files: components/GeneratedContentDisplay.js — the UI that inserts and displays a clip — and an internal engineering runbook documenting that same flow. It appears nowhere inside lib/export/, lib/content-export.js, or any app/api export route, for any of the seven formats — HTML, Word, PowerPoint, Text, PDF, TeX, and JSON all route through the same extractContentData step first.

Why the Gap Exists Structurally

This isn't a bug hiding in one exporter — it's a consequence of where pluginMedia lives in the data model. Every export formatter is written against a specific format's generated data: a quiz's questions array, a worksheet's sections, a lesson plan's activities. pluginMedia was added as a sibling field on the content session, alongside that generated data, not inside it — so every formatter would need to be individually updated to know it exists, and none currently are.

What This Means in Practice

If you clip a reference diagram and insert it into a worksheet while drafting, then export that worksheet to hand out as a PDF or Word document, the exported file contains the worksheet's questions and formatting — and not the diagram. The same is true exporting to PowerPoint, TeX, HTML, Text, or JSON.

If the visual genuinely needs to reach students on paper, the practical workaround today is the same one that predates Plugins entirely: screenshot it, or embed it directly into the document after export, the way a teacher would with any other reference image.

What Actually Gates Access to Plugins

Unlike content generation itself, where credits and plan limits apply, Plugins carries none of that. The clip and insert routes check exactly one thing server-side: a valid, verified account — no plan-tier check and no credit balance check anywhere in the clip, media, list, or delete routes.

That means a free-tier teacher and a paid-tier teacher get the identical Plugins experience: the same 20,000-character text cap, the same 5MB image cap, the same 60-and-30-per-hour rate limits, gated only by a verified email address.

Why Clipping Reference Material Is a Genuinely Useful Habit, Even With This Limit

It's worth separating the honest limitation from the underlying instinct behind Plugins, because the instinct is well-supported even though the export path isn't there yet.

What the Research Actually Says About Pairing Words With Images

Richard Mayer's cognitive theory of multimedia learning — developed across a series of experiments and summarized in his widely cited Multimedia Learning — found that people build stronger understanding from material that pairs relevant words with relevant images than from words alone. The two are processed through separate channels and reinforce each other when they're properly matched (Mayer, 2001; Mayer & Moreno, 2003).

A labeled diagram sitting next to the passage that explains it is doing real cognitive work, not just decorating a page. That's the genuine case for clipping a diagram while researching a lesson: pairing a visual with the text you're building around it is a pedagogically grounded habit, independent of any single tool.

Where the Instinct and the Limitation Meet

Plugins makes the mechanical part of that habit — save it, keep it with the material, don't lose the source link — frictionless inside the app. What Mayer's research doesn't change is the export gap.

Multimedia learning theory is a case for why a teacher would want the diagram integrated into a lesson at all. It isn't evidence that EduGenius's export pipeline currently carries that integration into a downloadable file — it doesn't, and the two claims shouldn't be conflated.

Pro Tips

  • Treat Plugins as a drafting aid, not a publishing step. Insert a clip while you're building a lesson to keep the reference material in view, but plan your actual handout or slide deck around what the export will contain, not around what the editing screen shows you.
  • Keep the source link. A clip's source URL carries through to the Plugins library and the insert picker — useful if you later need to re-embed the original image manually into an exported document, or just want to credit the source.
  • Delete clips you've already used. Since the pool has no automatic expiry, a habit of clearing out clips once they've served their purpose keeps the library itself easy to scan rather than accumulating indefinitely.
  • Pair Plugins with Content History rather than instead of it. History finds a past generation; Plugins finds a past clip. They're separate archives for separate kinds of material, and confusing the two means checking the wrong one first.
  • If you regularly clip the same kind of reference material for a recurring lesson, save the generation setup as a Recipe — Recipes won't carry a clip forward automatically, but it removes the reconfiguration work around it each time you rebuild that lesson.

What to Avoid

  • Don't assume an inserted clip will appear in your exported file. It won't, in any of the seven export formats — verify this yourself by exporting a test file with a clip inserted before you build a lesson plan around the assumption that it travels through.
  • Don't clip an image expecting it to substitute for the export pipeline's own image handling elsewhere, such as in format-specific presentation slides — those are two entirely separate systems that happen to both produce visuals.
  • Don't rely on the 200-item library view for a very large archive of old clips. The list is capped at your 200 most recent; older clips still exist in Firestore but won't surface in the standard browse view once you're well past that count.
  • Don't expect a deleted clip to be recoverable. Deletion removes both the database record and, for images, the stored file — there's no trash or undo step.
  • Don't assume an inserted image thumbnail will look right if you come back the next day. Its link is time-limited to about an hour past insertion and is never refreshed — if you need the image later, re-open it from your Plugins library, where the link is always regenerated fresh.
  • Don't confuse Plugins with the extension's direct "turn selection into practice" shortcut. One saves the original material for later reference and insertion; the other immediately generates new content from the selection. They serve different moments in a teacher's workflow.

Key Takeaways

  • Plugins is a real, fully wired feature, not a stub: clipping, storage, browsing, deleting, and inserting are all live and connected to actual persistence.
  • Text clips cap at 20,000 characters and images at 5MB (JPEG, PNG, GIF, or WebP only), with rate limits of 60 text clips and 30 image clips per hour, enforced server-side.
  • Everything you clip lives at Library → Plugins, browsable and independently deletable, with deletion removing both the database record and any stored image file.
  • Inserting a clip appends it to a content session's pluginMedia field, visible on screen under "Inserted media" and persisted across reloads through the same content-session update path other inline edits use.
  • The honest limitation is real and verifiable in the code: none of EduGenius's seven export formats read pluginMedia — confirmed directly in lib/content-export.js's shared data-extraction step and in the JSON exporter's output payload, which contains no such field.
  • Access has no plan or credit gating at all — a verified, logged-in account is the only requirement, identical across free and paid tiers.
  • The underlying habit — pairing a reference visual with the material it explains — is genuinely well-supported by multimedia-learning research, even though today's export pipeline doesn't yet carry that pairing into a downloadable file.

Frequently Asked Questions

Will a clip I insert into a lesson show up when I export it to PDF or Word?

No. Inserted clips live in a pluginMedia field on the content session, and none of EduGenius's export formats — PDF, Word, PowerPoint, Text, HTML, TeX, or JSON — read that field. The clip stays visible only inside the app's editing view.

Is this a bug that's going to get fixed soon?

It isn't something this article can promise a timeline on. What's verifiable today is that the export code doesn't currently read pluginMedia in any format — that's a stable, checkable fact about the current pipeline, not a claim about future plans.

Does clipping content or inserting it cost credits?

No. Plugins has no credit or plan gating anywhere in its clip, browse, delete, or insert routes. The only requirement is a verified, signed-in account, the same on free and paid tiers.

What file types can I clip as an image?

JPEG, PNG, GIF, and WebP, capped at 5MB per image. Anything outside that allow-list or over the size cap is rejected by the server before it's stored.

How is Plugins different from turning a selection directly into a quiz with the extension?

Plugins saves the original clipped material to a personal pool for later reference or insertion. The extension's separate "turn selection into practice" shortcut skips that step and generates new content from the selection immediately — they solve different moments in a workflow, not the same one.

Can someone else see or access my clipped content?

No. Every clip route is scoped to your own account by its Firestore path, and image files live under a path tied to your user ID with only short-lived signed URLs ever returned to a browser — there's no shared or public Plugins pool.

Is there a limit to how many clips I can save?

There's no hard cap on your total pool size, but the standard library view surfaces your 200 most recent clips, and clipping itself is rate-limited to 60 text clips and 30 image clips per hour to prevent abuse rather than to ration normal use.

If I delete a clip after inserting it into a lesson, does it disappear from that lesson too?

No. The insert action copies the clip's data (title, text or image URL, source link) into the content session at the moment you insert it, so the already-inserted copy in that specific lesson isn't pulled automatically if you later delete the original from your Plugins pool. Treat the two as related but separate once a clip has been inserted somewhere.

#teachers#content-generation