@atom-forge/brickee 0.0.1 → 0.0.3

package/docs/hu/documents-and-markdown.md

@@ -46,13 +46,13 @@ Egy rövid dokumentum egy bekezdéssel, egy listával, egy videóval és egy dob
 | `md:p` | inline markdown | — | maga a szöveg |
 | `md:h1` … `md:h6` | inline markdown | — | `#` … `######` |
 | `md:ul` | inline markdown | — | `- item` |
-| `md:ol` | inline markdown | — | `1. item` (sorozatonként és behúzási szintenként számozva) |
+| `md:ol` | inline markdown | `{ start?: number }` a lista első elemén | `1. item` (sorozatonként és behúzási szintenként számozva, megadott `start`-tól) |
 | `md:todo` | inline markdown | `{ checked: boolean }` | `- [x] item` |
 | `md:quote` | inline markdown | — | `> quote` |
 | `md:code` | nyers szöveg | `{ lang?: string }` | kerített blokk a nyelvvel |
 | `md:hr` | — | — | `---` |
 
-Az `indent` egymásba ágyazza a listaelemeket (az egymást követő lista-blokkokból az előnézetben helyesen egymásba ágyazott `ul`/`ol` elemek lesznek), a bekezdéseket és az idézeteket pedig behúzza. A címsorok, a kódblokkok és az elválasztók figyelmen kívül hagyják.
+Az `indent` egymásba ágyazza a listaelemeket (az egymást követő lista-blokkokból az előnézetben helyesen egymásba ágyazott `ul`/`ol` elemek lesznek), a bekezdéseket és a kódblokkokat egy listaelem alá teszi, az idézeteket pedig egymásba ágyazza (`> > …`). A címsorok és az elválasztók figyelmen kívül hagyják.
 
 ### Inline markdown
 
@@ -60,15 +60,15 @@ A beépített blokkok szövege a markdown egy kicsi, biztonságos részhalmaza:
 
 | Jelölés | Tárolt alak |
 |---|---|
-| félkövér | `**text**` |
-| dőlt | `*text*` |
+| félkövér | `**text**` (beolvasva a `__text__` is) |
+| dőlt | `*text*` (beolvasva a `_text_` is, szón belül nem) |
 | aláhúzott, alsó index, felső index | `<u>text</u>`, `<sub>text</sub>`, `<sup>text</sup>` |
 | áthúzott | `~~text~~` |
-| kód | `` `text` `` |
-| hivatkozás | `[text](url)` – csak a `http:`, `https:`, `mailto:`, `tel:` és a webhelyen belüli `/…` célok lesznek hivatkozások |
-| sortörés | egy újsor karakter |
+| kód | `` `text` `` (hosszabb backtick-sorozattal, ha a kód backticket tartalmaz: ``` `` a`b `` ```) |
+| hivatkozás | `[text](url)` – csak a `http:`, `https:`, `mailto:`, `tel:` és a webhelyen belüli `/…` célok lesznek hivatkozások; a célban a zárójeleknek párosnak kell lenniük. Beolvasva a cím (elhagyva), a `<https://…>` autolink és a kép (`![alt](url)`) hivatkozásként is |
+| sortörés | egy újsor karakter (markdown-kimenetben: visszaperjel a sor végén) |
 
-Az egyszerű szövegben a speciális karakterek visszaperjeles escape-elést kapnak, így soha nem válnak jelöléssé. Az `inline(md)` az inline markdownt HTML-lé alakítja: előbb escape-eli a szöveget, és csak utána teszi hozzá a fenti tageket, így a kimenete biztonságosan megjeleníthető `{@html}`-lel – az előnézet is így tesz.
+Az egyszerű szövegben a speciális karakterek visszaperjeles escape-elést kapnak, így soha nem válnak jelöléssé; bármely ASCII írásjel escape-elhető. A beolvasás bármilyen bemeneten lineáris időben fut, ezekkel a korlátokkal: egy jelölt szakasz legfeljebb 2000 karakter, egy link címkéjében nem lehet saját szögletes zárójel, és legfeljebb 1000 karakter, egy link célja legfeljebb 2000. Beolvasáskor az inline HTML a jelölésekre képeződik le (`<strong>`, `<em>`, `<del>`, `<br>`…), a többi tag elmarad (a szövege megmarad), a `[^1]` lábjegyzet-hivatkozásból pedig felső index lesz. Az `inline(md)` az inline markdownt HTML-lé alakítja: előbb escape-eli a szöveget, és csak utána teszi hozzá a fenti tageket, így a kimenete biztonságosan megjeleníthető `{@html}`-lel – az előnézet is így tesz.
 
 ## Markdown be és ki
 
@@ -78,19 +78,19 @@ A markdown teljes értékű formátum: a vágólap ezt hordozza, és a befogadó
 |---|---|---|
 | `fromStored(block)` | `StoredBlock` → `Block` | bárhol |
 | `toStored(block)` | `Block` → `StoredBlock` | csak böngészőben |
-| `fromMarkdown(text)` | markdown → `Block[]` | bárhol |
-| `toMarkdown(blocks, { plugins, media })` | `Block[]` → markdown | csak böngészőben |
+| `fromMarkdown(text, { plugins })` | markdown → `Block[]` | bárhol |
+| `fromHtml(html, { plugins })` | HTML (formázott beillesztés, egy oldal) → `Block[]` | csak böngészőben |
+| `toMarkdown(blocks, { plugins })` | `Block[]` → markdown | csak böngészőben |
 | `inline(md)` | inline markdown → inline HTML | bárhol |
 
 A markdown-függvények a szerkesztő alakján (`Block[]`) dolgoznak, ezért a tárolt dokumentumok a `fromStored` és a `toStored` függvényen mennek át:
 
 ```ts
-import { fromMarkdown, fromStored, toMarkdown, toStored, type MediaItem, type StoredBlock } from '@atom-forge/brickee';
+import { fromMarkdown, fromStored, toMarkdown, toStored, type StoredBlock } from '@atom-forge/brickee';
 import { PLUGINS } from '@atom-forge/brickee/plugins';
 
 // Tárolt dokumentum -> markdown (csak böngészőben).
-export const exportMarkdown = (doc: StoredBlock[], media: MediaItem[]) =>
-	toMarkdown(doc.map(fromStored), { plugins: PLUGINS, media });
+export const exportMarkdown = (doc: StoredBlock[]) => toMarkdown(doc.map(fromStored), { plugins: PLUGINS });
 
 // Markdown -> tárolt dokumentum (csak böngészőben).
 export const importMarkdown = (text: string): StoredBlock[] => fromMarkdown(text).map(toStored);
@@ -102,14 +102,19 @@ export const importMarkdown = (text: string): StoredBlock[] => fromMarkdown(text
 
 Amit a `fromMarkdown` beolvas:
 
-- címsorok, felsorolás-, számozott és teendő-elemek, idézetek, kerített kódblokkok a nyelvükkel, elválasztók és a fenti inline jelölések;
-- a sor eleji szóközök behúzásként (szintenként két szóköz vagy egy tabulátor);
-- minden nem üres sor külön blokként – a tördelt sorokat nem vonja össze egy bekezdéssé, és csak beépített blokkokat hoz létre (táblázatot, képet vagy plugin-blokkot nem).
+- címsorok (setext alakban is: `===`-vel vagy `---`-val aláhúzott sor, és záró `#`-ekkel), felsorolás-, számozott (a kezdőszámukkal) és teendő-elemek, idézetek (a beágyazottak egy szinttel mélyebben), kerített kód (backtick vagy tilde, tetszőleges hosszal, legalább ugyanilyen hosszú kerítés zárja) és behúzott kód, elválasztók és a fenti inline jelölések;
+- a listák egymásba ágyazását az elemek jelölői szerint: az a sor, amely beljebb kezdődik egy elem jelölőjénél, az elemen belül van (így a `1. ` elemek alá két, három vagy négy szóközzel is lehet ágyazni);
+- egy bekezdés, listaelem vagy idézet sorait egy blokként, köztük sortöréssel; üres sor, idézetben a magában álló `>` új blokkot kezd;
+- a hivatkozásos linkeket (`[text][id]` és `[id]: url`) feloldva, a lábjegyzet-definíciókat a számuk utáni bekezdésként;
+- a GFM-táblázatot a `plugins` közül az első olyan plugin blokkjaként, amelyik fogad táblázatot (`fromTable`, lásd [Pluginok írása](writing-plugins.md#beillesztett-táblázatok-fogadása); a beépített `table` ilyen), különben szövegként. A szerkesztő átadja a felkínált pluginjait, így egy beillesztett táblázatból táblázat blokk lesz.
+
+Amit a `fromHtml` beolvas – a szerkesztő ezt használja weboldalról, Google Docsból vagy Wordből érkező formázott beillesztéshez: címsorok, bekezdések, listák (beágyazva, a számozottak a kezdőszámukkal, a teendők a jelölőnégyzetekből), idézetek, kód (`pre`, `language-…` osztállyal), elválasztók, táblázatok (egy azt fogadó pluginnak) és az inline jelölések – a Google Docs félkövér, dőlt és áthúzott spanjei is. A képekből link lesz (a csomagban nincs képfogalom), a scriptek, stílusok és űrlapelemek kimaradnak. A HTML-t csak olvassa: markdownon és ugyanazon a biztonságos megjelenítésen megy át, mint minden más.
 
 Amit a `toMarkdown` kiír:
 
-- az egymást követő listaelemeket egymást követő sorokba, minden más blokkot üres sorral elválasztva;
-- a listaelemeket és a bekezdéseket szintenként két szóközzel behúzva;
-- a plugin-blokkot a pluginja `markdown(props, { inner, media })` függvényével, ahol az `inner` a már átalakított beágyazott blokkjai; a markdown alak nélküli plugin, illetve az, amelyik `''`-t ad vissza, kimarad.
+- az egymást követő listaelemeket egymást követő sorokba, az egymást követő idézeteket egyetlen idézetként (bekezdéseik között `>`), minden más blokkot üres sorral elválasztva;
+- a beágyazott elemeket, valamint egy elem alatti bekezdéseket és kódot az elem tartalmáig behúzva (`- ` alatt két, `1. ` alatt három, `10. ` alatt négy szóközzel);
+- a kódot minden benne lévő backtick-sorozatnál hosszabb kerítésben, az egyszerű szöveget pedig ott escape-elve, ahol a markdown jelölésnek olvasná (`\_`, sor elején `1\.`…);
+- a plugin-blokkot a pluginja `markdown(props, { inner })` függvényével, ahol az `inner` a már átalakított beágyazott blokkjai; a markdown alak nélküli plugin, illetve az, amelyik `''`-t ad vissza, kimarad.
 
 Saját pluginod markdown alakjának megírásáról a [Pluginok írása](writing-plugins.md#markdown-alak) fejezet szól.

package/docs/hu/editor-and-preview.md

@@ -6,12 +6,11 @@
 
 | Prop | Típus | Alapérték | Jelentés |
 |---|---|---|---|
-| `value` | `StoredBlock[]` (bindable) | `[]` | A dokumentum. Minden változáskor visszaíródik; a kívülről lecserélt dokumentum újra betöltődik. |
+| `value` | `StoredBlock[]` (bindable) | `[]` | A dokumentum. Minden változáskor visszaíródik (a változatlan blokkok megtartják az objektumukat); a kívülről lecserélt dokumentum – új tömb, nem helyben módosított – újra betöltődik, hacsak nem egyezik a mostanival. |
 | `plugins` | `BlockPlugin[]` | `[]` | A pluginblokkok, amelyeket ez a szerkesztő megjeleníthet és felkínálhat. |
 | `palette` | `string[]` | minden beépített blokk, utána minden plugin | A perjeles menü által felkínált blokktípusok, ebben a sorrendben (lásd lent). |
-| `media` | `MediaItem[]` | — | A képek, amelyek közül a blokkok választhatnak (lásd [Az alkalmazás kontextusai](host-contexts.md)). |
 | `messages` | `Messages` | — | Felületi szövegek az alkalmazás nyelvén: angol szöveg → fordítás. |
-| `readonly` | `boolean` | `false` | Szerkesztés nélkül mutatja a dokumentumot; a pluginmezők rejtve vannak. |
+| `readonly` | `boolean` | `false` | Szerkesztés nélkül mutatja a dokumentumot; a pluginmezők rejtve vannak. Az írásvédett szerkesztő soha nem írja a `value`-t. |
 | `placeholder` | `string` | `Write something, or press '/' for blocks…` | Az üres blokk tippszövege. |
 | `nested` | `boolean` | `false` | A beágyazott blokkokat tartalmazó pluginok állítják be a belső szerkesztőjükön; a befogadó alkalmazás soha nem állítja be. |
 
@@ -23,16 +22,14 @@ Az üres dokumentum egyetlen üres bekezdésként jelenik meg, így a szerkeszt
 |---|---|---|---|
 | `blocks` | `StoredBlock[]` | — | A megjelenítendő dokumentum. |
 | `plugins` | `BlockPlugin[]` | — | A pluginok, amelyek előnézetei a pluginblokkokat renderelik. |
-| `media` | `MediaItem[]` | — | A képek, amelyekre a blokkok azonosítóval hivatkoznak. |
 | `messages` | `Messages` | — | Felületi szövegek az alkalmazás nyelvén. |
-| `markGated` | `boolean` | `true` | Megjelöli a kapus blokk utáni blokkokat (lásd [Egyedi és kapus blokkok](writing-plugins.md#egyedi-és-kapus-blokkok)). |
 | `nested` | `boolean` | `false` | A beágyazott blokkjaikat renderelő plugin-előnézetek állítják be. |
 
 Az előnézet a beépített blokkokat sima HTML-ként rendereli (`p`, `h1`…`h6`, `ul`/`ol` beágyazott elemekkel, `blockquote`, `pre > code` `language-<lang>` osztállyal, `hr`), a pluginblokkokat pedig a pluginjuk `preview` komponensével. Az a blokk, amelynek típusához nincs plugin a `plugins` listában, vagy amelynek pluginjának nincs `preview`-ja, nem renderelődik.
 
 Hogy használod-e egyáltalán a `Preview`-t, rajtad múlik: a szerkesztő nem függ tőle. Egy saját megjelenítővel dolgozó alkalmazás maga is renderelheti a tárolt blokkokat, és a pluginjai elhagyhatják a `preview`-t.
 
-A legfelső szintű szerkesztőnek vagy előnézetnek átadott `media` és `messages` öröklődik minden alatta lévő beágyazott szerkesztőre, beágyazott előnézetre és pluginkomponensre.
+A legfelső szintű szerkesztőnek vagy előnézetnek átadott `messages` öröklődik minden alatta lévő beágyazott szerkesztőre, beágyazott előnézetre és pluginkomponensre.
 
 ## A paletta
 
@@ -74,10 +71,10 @@ A `PALETTE_ITEMS` a beépített blokkokat sorolja fel a címkéikkel, tippjeikke
 | Szövegformázás | Jelölj ki szöveget az eszköztárhoz, vagy `Ctrl/Cmd` + `B` félkövér, `I` dőlt, `U` aláhúzott, `Shift+X` áthúzott, `E` kód, `K` link, `\` formázás eltávolítása. Az alsó és a felső index az eszköztáron érhető el. |
 | Behúzás | `Tab` / `Shift+Tab` (legfeljebb 6 szint). |
 | Sortörés | `Shift+Enter`; kódblokkban az `Enter` töri a sort, a `Shift+Enter` vagy a `Ctrl/Cmd+Enter` pedig új blokkot kezd. |
-| Blokkok kijelölése | Kattints egy blokk fogantyújára, nyomj `Esc`-et egy blokkban, `Shift+↑/↓` a blokk szélén túl, vagy húzz szövegkijelölést több blokkon át. Üres blokkban a `Ctrl/Cmd+A` minden blokkot kijelöl. |
-| Blokkok mozgatása | Húzd a fogantyút (beágyazott szerkesztőkbe be és onnan ki is), vagy `Ctrl/Cmd+Shift+↑/↓`. |
-| Átalakítás | Kattints egy blokk vagy egy kijelölés fogantyújára az „Átalakítás” menühöz. |
-| Másolás, kivágás | A kijelölt blokkok másolásakor a markdownjuk kerül a vágólapra (a pluginblokkok a markdown alakjukon keresztül). |
+| Blokkok kijelölése | Kattints (vagy koppints) egy blokk fogantyújára, nyomj `Esc`-et egy blokkban, `Shift+↑/↓` a blokk szélén túl, vagy húzz szövegkijelölést több blokkon át. Üres blokkban a `Ctrl/Cmd+A` minden blokkot kijelöl. |
+| Blokkok mozgatása | Húzd a fogantyút (beágyazott szerkesztőkbe be és onnan ki is), `Ctrl/Cmd+Shift+↑/↓`, vagy az „Átalakítás” menü *Mozgatás fel* / *Mozgatás le* pontja (húzás nélkül: érintőképernyő, billentyűzet). |
+| Átalakítás | Kattints egy blokk vagy egy kijelölés fogantyújára az „Átalakítás” menühöz; billentyűzetről a kijelölt blokkokon `/` (vagy `Ctrl/Cmd+/`, a menübillentyű, `Shift+F10`), egy blokk szövegében `Ctrl/Cmd+/`. Érintőképernyőn a megkoppintott blokk a fogantyúja mellett mutatja a műveleteit (új blokk alá, átalakítás, törlés). |
+| Másolás, kivágás, beillesztés | A kijelölt blokkok másolásakor a markdownjuk kerül a vágólapra (a pluginblokkok a markdown alakjukon keresztül), mellé pedig maguk a blokkok is (`application/x-brickee+json`). Máshonnan (weboldal, Google Docs, Word) érkező formázott szöveg megtartja a címsorait, listáit, táblázatait és jelöléseit (`fromHtml`); a sima szöveget markdownként olvassa. Brickee-szerkesztőbe illesztve a másolt blokkok változatlanul jönnek vissza; az a pluginblokk, amelyet az a szerkesztő nem kínál fel (vagy egy második egyedi), a markdown alakjára esik vissza. Bárhová máshová illesztve a markdown érkezik. Blokk-kijelölés közben beillesztve a blokkok a kijelölés után kerülnek. |
 | Beillesztés | A többsoros szöveg markdownként értelmeződik, és blokkokká válik. |
 | Visszavonás, újra | `Ctrl/Cmd+Z`, `Ctrl/Cmd+Shift+Z` vagy `Ctrl/Cmd+Y`. |
 

package/docs/hu/getting-started.md

@@ -10,7 +10,7 @@ Minden más plugin. A plugin egy egyszerű objektum (`BlockPlugin`), amely megne
 
 - egy **nézetet** — a szerkesztőben megjelenő Svelte-komponenst;
 - egy **előnézetet** — a blokkot az oldalon megjelenítő Svelte-komponenst;
-- **mezőket** — a blokk tetején megjelenő beállításokat (szöveg, szín, választó, csúszka, kép…);
+- **mezőket** — a blokk tetején megjelenő beállításokat (szöveg, szín, választó, csúszka…);
 - opcionálisan egy **markdown alakot**, amelyet a dokumentum markdownként való másolásakor vagy exportálásakor használ.
 
 A csomag négy általános plugint is tartalmaz — táblázat, YouTube-videó, térkép és térköz —, de ezek is ugyanolyan pluginok, mint bármelyik más: a magban semmi sem függ tőlük, és csak azokat adod át, amelyeket szeretnél. A képblokkokat, dobozokat és más, az oldalra jellemző blokkokat te írod meg pluginként.
@@ -24,7 +24,7 @@ bun add @atom-forge/brickee @atom-forge/ui @lucide/svelte
 | Peer dependency | Miért |
 |---|---|
 | `svelte` `^5.0.0` | A szerkesztő, az előnézet és a pluginok Svelte 5 komponensek. |
-| `@atom-forge/ui` `>=0.0.37` | A felugró ablakok (linkbekérő, képválasztó) és a blokkmezők űrlapvezérlői. |
+| `@atom-forge/ui` `>=0.0.37` | A felugró ablakok (linkbekérő) és a blokkmezők űrlapvezérlői. |
 | `@lucide/svelte` `>=1.0.0` | A blokkok ikonjai. |
 | `zod` `^4.0.0` (opcionális) | Csak az `@atom-forge/brickee/schema` szerveroldali sémájához. |
 
@@ -33,10 +33,22 @@ bun add @atom-forge/brickee @atom-forge/ui @lucide/svelte
 A blokkmezők és a felugró ablakok `@atom-forge/ui` komponensek, ezért az alkalmazást úgy kell beállítani, ahogy az `@atom-forge/ui` megköveteli:
 
 - Tailwind CSS 4, importált `@atom-forge/ui` téma-CSS-sel, a `dist` mappáját pedig add hozzá Tailwind `@source`-ként;
+- az `@atom-forge/brickee` `dist` mappája is legyen Tailwind `@source`: a szerkesztő Tailwind-osztályokkal és az `@atom-forge/ui` téma színeivel van stílusozva, ezért a Tailwindnek látnia kell őket:
+
+  ```css
+  @source "../node_modules/@atom-forge/ui/dist";
+  @source "../node_modules/@atom-forge/brickee/dist";
+  ```
+
+  Az előnézetnek egyik sem kell: a kevés stílusa a jelölésével együtt utazik, így Tailwind nélküli nyilvános oldal is mutathat dokumentumokat;
 - az alkalmazás az `@atom-forge/ui` `Root` komponense alatt renderelődjön, amely a témát és az overlay-kontextusokat biztosítja.
 
 A legfelső szintű `Editor` saját felugróablak-kezelőt hoz létre, és saját felugróablak-tárolót renderel; a pluginblokkokba ágyazott szerkesztők ezt használják közösen.
 
+A szerkesztő a színeit az `@atom-forge/ui` téma tokenjeiből veszi (`--color-surface`, `--color-frame`, `--color-muted-contrast`…), így követi a befogadó alkalmazás világos és sötét módját. Az előnézet keretei és képaláírásai az oldal szövegszínéből számolódnak.
+
+A blokkok fogantyúi a **szerkesztő dobozától balra**, egy kb. 22 px széles sávban jelennek meg: a szerkesztőt körülvevő elemnek legyen ennyi bal oldali paddingje, különben a fogantyúk kilógnak belőle.
+
 > **Hiányzó téma**
 >
 > Az `@atom-forge/ui` téma-CSS nélkül a szerkesztő továbbra is működik, de a blokkmezők, a színválasztó, a csúszka és a felugró ablakok stílus nélkül jelennek meg.

package/docs/hu/host-contexts.md

@@ -2,143 +2,21 @@
 
 [← Előző](writing-plugins.md) · [Tartalom](index.md) · [Következő →](server-side.md)
 
-A szerkesztőnek nincsenek propjai az alkalmazás fogalmaihoz. Amit a befogadó alkalmazás tud — a képeit, az éppen mutatott oldalszélességet, a nyelvét —, az három Svelte-kontextuson keresztül jut el a pluginokhoz. Mindegyikhez tartozik egy `provide…` függvény, amelyet a szerkesztő vagy az előnézet fölötti komponens inicializálásakor hívsz meg, és egy `use…` függvény a plugin-komponensek számára.
+A szerkesztőnek nincsenek propjai az alkalmazás fogalmaihoz. Amit a befogadó alkalmazás tud — az éppen mutatott oldalszélességet, a kiemelhető kódnyelveket, a nyelvét —, az három Svelte-kontextuson keresztül jut el a pluginokhoz. Mindegyikhez tartozik egy `provide…` függvény, amelyet a szerkesztő vagy az előnézet fölötti komponens inicializálásakor hívsz meg, és egy `use…` függvény a plugin-komponensek számára.
 
 | Kontextus | Megadás | Olvasás | Mit hordoz |
 |---|---|---|---|
-| Média | `media` prop, vagy `provideMedia(() => list)` | `useMedia()` | A képek, amelyek közül a blokkok választhatnak. |
 | Nézet | `provideView(() => key)` | `useView()` | A nézet, amelyet a nézetenkénti mezők szerkesztenek. |
+| Kódnyelvek | `provideCodeLanguages(() => list)` | `useCodeLanguages()` | A nyelvek, amelyeket a kódblokk felkínál. |
 | Szöveg | `messages` prop, vagy `provideText(() => messages)` | `useText()` | Felületi szövegek az alkalmazás nyelvén. |
 
 A beágyazott szerkesztők és előnézetek mindhármat a szülőjüktől öröklik.
 
-## Média
-
-A blokkok soha nem tárolnak kép-URL-t. A képmező egy `MediaItem` **azonosítóját** tárolja, a szerkesztő, az előnézet és a pluginok pedig a dokumentum médiájában keresik ki az elemet:
-
-```ts
-interface MediaItem {
-	id: string; // a blokk propsában tárolva
-	name: string; // fájlnév vagy cím, a választóban jelenik meg
-	url: string; // a kép címe
-	group?: string; // címsor a választóban (pl. a melléklet kategóriája)
-}
-```
-
-A mellékelt pluginok nem használnak képeket; a képblokkokat neked kell megírnod, mert az elrendezésük az oldalé. Egy minimális `photo` plugin — képmező, alternatív szöveg és magasságcsúszka:
-
-```svelte
-<!-- PhotoView.svelte -->
-<script lang="ts" module>
-	export interface PhotoProps extends Record<string, unknown> {
-		/** Egy MediaItem azonosítója. */
-		image: string;
-		alt: string;
-		/** A magasság a szélesség %-ában (20–150), vagy beállítatlan a kép saját alakjához. */
-		ratio?: unknown;
-	}
-
-	/** CSS aspect-ratio egy tárolt magasságból, vagy undefined. */
-	export const aspect = (v: unknown) => {
-		const n = Number(v);
-		return n >= 20 && n <= 150 ? `100 / ${n}` : undefined;
-	};
-</script>
-
-<script lang="ts">
-	import { ImageIcon } from '@lucide/svelte';
-	import { Empty, findMedia, useMedia, type PluginViewProps } from '@atom-forge/brickee';
-
-	let { props = $bindable(), blocks = $bindable() }: PluginViewProps<PhotoProps> = $props();
-	const media = useMedia();
-	const item = $derived(findMedia(media(), props.image));
-</script>
-
-{#if item}
-	<img src={item.url} alt={props.alt} style="max-width: 100%" />
-{:else}
-	<Empty icon={ImageIcon} text="Pick an image above" />
-{/if}
-```
-
-```svelte
-<!-- PhotoPreview.svelte -->
-<script lang="ts">
-	import { baseValue, findMedia, useMedia, type PluginPreviewProps } from '@atom-forge/brickee';
-	import { aspect, type PhotoProps } from './PhotoView.svelte';
-
-	let { props }: PluginPreviewProps<PhotoProps> = $props();
-	const media = useMedia();
-	const item = $derived(findMedia(media(), props.image));
-</script>
-
-{#if item}
-	<img src={item.url} alt={props.alt ?? ''} style:aspect-ratio={aspect(baseValue(props.ratio))} />
-{/if}
-
-<style>
-	img {
-		width: 100%;
-		object-fit: cover;
-	}
-</style>
-```
-
-```ts
-// photo.ts
-import { ImageIcon } from '@lucide/svelte';
-import { findMedia, mdText, type BlockPlugin } from '@atom-forge/brickee';
-import PhotoView, { type PhotoProps } from './PhotoView.svelte';
-import PhotoPreview from './PhotoPreview.svelte';
-
-export const photo: BlockPlugin<PhotoProps> = {
-	type: 'photo',
-	label: 'Photo',
-	hint: 'One picked image',
-	keys: 'photo image picture',
-	icon: ImageIcon,
-	props: () => ({ image: '', alt: '' }),
-	fields: [
-		{ key: 'image', label: 'Image', kind: 'image' },
-		{ key: 'alt', label: 'Alt text', kind: 'text', placeholder: 'What the image shows' },
-		{ key: 'ratio', label: 'Height', kind: 'slider', min: 20, max: 150, unit: '%', none: 'Original' }
-	],
-	tag: () => 'photo',
-	content: 'none',
-	markdown: (p, { media }) => {
-		const url = findMedia(media, p.image)?.url;
-		return url ? `![${mdText(p.alt)}](${url})` : '';
-	},
-	view: PhotoView,
-	preview: PhotoPreview
-};
-```
-
-A szerkesztőnek és az előnézetnek ugyanazt a médiát add:
-
-```svelte
-<script lang="ts">
-	import { Editor, Preview, type MediaItem, type StoredBlock } from '@atom-forge/brickee';
-	import { photo } from './photo';
-
-	let { value = $bindable(), media }: { value: StoredBlock[]; media: MediaItem[] } = $props();
-</script>
-
-<Editor bind:value plugins={[photo]} {media} />
-<Preview blocks={value} plugins={[photo]} {media} />
-```
-
-Plugin-komponensben a listát a `useMedia()`-val olvasd ki — függvényt ad vissza, így a lista mindig friss marad —, egy elemet pedig a `findMedia(list, id)`-vel keress meg, ahogy a photo nézete és előnézete is teszi.
-
-> **Bélyegképek a szerkesztőben**
->
-> A szerkesztőnek csak kis képekre van szüksége. Mivel a blokkok azonosítókat tárolnak, a szerkesztőnek adhatsz egy bélyegkép-URL-ekből álló listát, az oldalon lévő előnézetnek pedig egy teljes méretű URL-ekből állót, ugyanazokkal az azonosítókkal.
-
-Tipikus forrás egy oldal feltöltött mellékletei vagy egy médiatár. Minden képnek, amelyre egy dokumentum hivatkozik, szerepelnie kell a listában, különben a blokkja semmit sem renderel.
+A képek nem kontextuson keresztül érkeznek: hogy egy képblokk mit tárol, és honnan veszi a képeit, azt az alkalmazás saját pluginja dönti el (lásd [Képek](writing-plugins.md#képek)).
 
 ## Nézetenkénti értékek
 
-Egyes beállítások attól függnek, hogyan jelenik meg az oldal: egy képnek telefonon más képarány kellhet, mint széles képernyőn. A `views` beállítással rendelkező `slider` mező nézetenként tárol értéket:
+Egyes beállítások attól függnek, hogyan jelenik meg az oldal: egy képnek telefonon más képarány kellhet, mint széles képernyőn. A `views` beállítással rendelkező `slider` mező nézetenként tárol értéket. Itt ez a [Pluginok írása](writing-plugins.md#képek) fejezet `photo` pluginjának magassága és a mellékelt `gap`:
 
 ```ts
 import type { BlockPlugin } from '@atom-forge/brickee';
@@ -184,18 +62,17 @@ Az előnézet a `viewValues(value, keys)`-szel olvassa ki őket — minden néze
 
 ```svelte
 <script lang="ts">
-	import { findMedia, useMedia, viewValues, type PluginPreviewProps } from '@atom-forge/brickee';
-	import { aspect, type PhotoProps } from './PhotoView.svelte';
+	import { viewValues, type PluginPreviewProps } from '@atom-forge/brickee';
+	import { aspect, imageSrc, type PhotoProps } from './PhotoView.svelte';
 
 	let { props }: PluginPreviewProps<PhotoProps> = $props();
-	const media = useMedia();
-	const item = $derived(findMedia(media(), props.image));
+	const src = $derived(imageSrc(props.url));
 	// desktop, tablet, phone: mindegyikhez egy CSS aspect-ratio ('auto': a kép saját alakja)
 	const r = $derived(viewValues(props.ratio, ['desktop', 'tablet', 'phone']).map((v) => aspect(v) ?? 'auto'));
 </script>
 
-{#if item}
-	<img src={item.url} alt={props.alt ?? ''} style:--r-desktop={r[0]} style:--r-tablet={r[1]} style:--r-phone={r[2]} />
+{#if src}
+	<img {src} alt={props.alt ?? ''} style:--r-desktop={r[0]} style:--r-tablet={r[1]} style:--r-phone={r[2]} />
 {/if}
 
 <style>
@@ -221,6 +98,23 @@ Az előnézet a `viewValues(value, keys)`-szel olvassa ki őket — minden néze
 >
 > A `views` a `slider` mezőkön támogatott. A többi mezőfajta figyelmen kívül hagyja.
 
+## Kódnyelvek
+
+A kódblokk nyelve (`props.lang`, a markdown-kerítés info-szövege) alapból szabad szöveg. Ha az alkalmazás tudja, mely nyelveket tud kiemelni az oldala, megadja a listát, és a kódblokk mezősávjában a mező legördülő lista lesz, elején a *Nincs* opcióval:
+
+```svelte
+<script lang="ts">
+	import { Editor, provideCodeLanguages, type StoredBlock } from '@atom-forge/brickee';
+
+	let { value = $bindable() }: { value: StoredBlock[] } = $props();
+	provideCodeLanguages(() => [{ value: 'ts', label: 'TypeScript' }, { value: 'svelte', label: 'Svelte' }, 'css', 'bash']);
+</script>
+
+<Editor bind:value />
+```
+
+Egy elem string vagy `{ value, label? }`; a `value` kerül tárolásra. A beágyazott szerkesztők öröklik a listát. Egy tárolt nyelv, amely nincs a listában, opció marad, így egy régebbi dokumentum megnyitásakor semmi sem vész el.
+
 ## Felületi szövegek
 
 A szerkesztő és a pluginok angolul íródtak, és az angol szöveg a fordításának kulcsa. Add át a `messages`-t — egy objektumot, amely az angol szövegeket a te nyelvedre képezi le — a legfelső szintű szerkesztőnek és előnézetnek:

package/docs/hu/index.md

@@ -19,7 +19,7 @@ flowchart TB
 - **Mellékelt pluginok** (`@atom-forge/brickee/plugins`) — ugyanolyan pluginok, mint bármelyik más, és csak abból készültek, amit a mag exportál. Csak azokat kapcsolod be, amelyekre szükséged van.
 - **A saját pluginjaid** — ugyanaz a `BlockPlugin` alak, az alkalmazásodban.
 
-Maga a szerkesztő semmit sem tud az alkalmazásodról. Amire egy alkalmazásnak szüksége van — a képei, az oldalszélességei, a nyelve —, az **kontextusokon** (média, nézet, szöveg) vagy a pluginok **mezőin** keresztül jut el a pluginokhoz, soha nem külön szerkesztő-propokon át.
+Maga a szerkesztő semmit sem tud az alkalmazásodról. Amire egy alkalmazásnak szüksége van — az oldalszélességei, a kódnyelvei, a nyelve —, az **kontextusokon** (nézet, kódnyelvek, szöveg) vagy a pluginok **mezőin** keresztül jut el a pluginokhoz, soha nem külön szerkesztő-propokon át. A képek sem kivételek: a képblokk a saját pluginod, amely úgy tárolja, választja ki és oldja fel a képeit, ahogy az alkalmazásod teszi.
 
 ## Tartalom
 
@@ -27,12 +27,12 @@ Maga a szerkesztő semmit sem tud az alkalmazásodról. Amire egy alkalmazásnak
 2. [A szerkesztő és az előnézet](editor-and-preview.md) — az `Editor` és a `Preview` propjai, a paletta, a szerkesztési funkciók és a görgetés-szinkron.
 3. [Dokumentumok és markdown](documents-and-markdown.md) — a tárolt alak (`StoredBlock`), a beépített blokkok, valamint az átalakítás markdownból és markdownba.
 4. [Mellékelt pluginok](bundled-plugins.md) — mit tartalmaz az `@atom-forge/brickee/plugins`, és hogyan írhatsz felül egy előnézetet vagy adhatsz hozzá mezőket.
-5. [Pluginok írása](writing-plugins.md) — a `BlockPlugin` felépítése, mezők, nézetek és előnézetek, tárolók, markdown alakok és a kit.
-6. [Az alkalmazás kontextusai](host-contexts.md) — média, nézetenkénti értékek és felületi szövegek.
-7. [A szerveren](server-side.md) — sémavalidálás, sima szöveg és védett tartalom.
+5. [Pluginok írása](writing-plugins.md) — a `BlockPlugin` felépítése, mezők, nézetek és előnézetek, tárolók, markdown alakok, képblokkok és a kit.
+6. [Az alkalmazás kontextusai](host-contexts.md) — nézetenkénti értékek, kódnyelvek és felületi szövegek.
+7. [A szerveren](server-side.md) — sémavalidálás, sima szöveg.
 8. [Receptek és buktatók](recipes-and-pitfalls.md) — teljes minták és az elkerülendő hibák.
 9. [Frissítés](upgrading.md) — mit kell módosítanod a kódodban, amikor újabb verzióra váltasz.
 
 A könyvben van egy AI Notes fejezet is: utasítások, amelyeket a csomagot használó projekt ágens-utasításfájljába másolhatsz.
 
-A Svelte-példák teljes komponensek, hacsak másként nem jelzik. Az alkalmazásbeli értékek, például a képek listája vagy az aktuális oldalszélesség, azt jelölik, amit az alkalmazásod biztosít.
+A Svelte-példák teljes komponensek, hacsak másként nem jelzik. Az alkalmazásbeli értékek, például az aktuális oldalszélesség, azt jelölik, amit az alkalmazásod biztosít.

package/docs/hu/recipes-and-pitfalls.md

@@ -38,23 +38,22 @@ export const messages: Messages = { ...hu, Button: 'Gomb', 'A link as a button':
 ```svelte
 <!-- lib/BlockEditor.svelte -->
 <script lang="ts">
-	import { Editor, provideView, type MediaItem, type StoredBlock } from '@atom-forge/brickee';
+	import { Editor, provideView, type StoredBlock } from '@atom-forge/brickee';
 	import { messages, PAGE_PALETTE, plugins } from './blocks';
 
 	let {
 		value = $bindable(),
-		media = [],
 		palette = PAGE_PALETTE,
 		view
-	}: { value: StoredBlock[]; media?: MediaItem[]; palette?: string[]; view?: string } = $props();
+	}: { value: StoredBlock[]; palette?: string[]; view?: string } = $props();
 
 	provideView(() => view);
 </script>
 
-<Editor bind:value {plugins} {palette} {media} {messages} />
+<Editor bind:value {plugins} {palette} {messages} />
 ```
 
-A közzétett oldalt a `<Preview blocks={doc} {plugins} {media} {messages} />`-val és ugyanazokkal a `plugins`-szal rendereld, így egy blokk ugyanúgy néz ki a szerkesztő előnézetében és az oldalon.
+A közzétett oldalt a `<Preview blocks={doc} {plugins} {messages} />`-val és ugyanazokkal a `plugins`-szal rendereld, így egy blokk ugyanúgy néz ki a szerkesztő előnézetében és az oldalon.
 
 ## A teljes dokumentum másolása markdownként
 
@@ -62,13 +61,13 @@ A kijelölt blokkok másolása már most is markdownt tesz a vágólapra. Egy, a
 
 ```svelte
 <script lang="ts">
-	import { fromStored, toMarkdown, type MediaItem, type StoredBlock } from '@atom-forge/brickee';
+	import { fromStored, toMarkdown, type StoredBlock } from '@atom-forge/brickee';
 	import { plugins } from './blocks';
 
-	let { doc, media = [] }: { doc: StoredBlock[]; media?: MediaItem[] } = $props();
+	let { doc }: { doc: StoredBlock[] } = $props();
 
 	// Kattintáskezelőben fut, így a csak böngészőben működő toMarkdown itt biztonságos.
-	const copy = () => navigator.clipboard.writeText(toMarkdown(doc.map(fromStored), { plugins, media }));
+	const copy = () => navigator.clipboard.writeText(toMarkdown(doc.map(fromStored), { plugins }));
 </script>
 
 <button type="button" onclick={copy}>Copy as markdown</button>
@@ -83,7 +82,7 @@ import { fromMarkdown, toStored, type StoredBlock } from '@atom-forge/brickee';
 export const fromText = (text: string): StoredBlock[] => fromMarkdown(text).map(toStored);
 ```
 
-Ne feledd, hogy minden nem üres sorból külön blokk lesz.
+Egy bekezdés sorai egy blokk maradnak, köztük sortöréssel; üres sor új blokkot kezd.
 
 ## Fejlesztés helyi másolattal
 
@@ -105,15 +104,17 @@ Az alkalmazás a csomag lefordított `dist/` mappáját olvassa, ezért minden v
 
 | Tünet | Ok | Megoldás |
 |---|---|---|
+| A szerkesztő sorai, menüi vagy táblázata stílus nélküliek vagy összezsugorodnak | Az `@atom-forge/brickee` `dist` mappája nem Tailwind `@source` | Vedd fel az `@source "../node_modules/@atom-forge/brickee/dist";` sort az `@atom-forge/ui`-é mellé. |
 | A blokkmezők és a popupok stílus nélkülinek tűnnek | Hiányzik az `@atom-forge/ui` téma CSS-e vagy a Tailwind `@source`-a | Állítsd be az `@atom-forge/ui`-t a dokumentációja szerint, és az alkalmazást a `Root`-ja alatt rendereld. |
+| A blokkfogantyúk balra kilógnak | A fogantyúk a szerkesztő dobozától balra jelennek meg | Adj a szerkesztőt körülvevő elemnek kb. 22 px bal oldali paddinget. |
 | A popupok nem nyílnak meg, vagy „context not found” hibák linkelt csomaggal | A `svelte` vagy az `@atom-forge/ui` két példányban van jelen | Vedd fel őket a Vite `resolve.dedupe` listájába. |
 | Egy plugin blokkja „Unknown block” feliratot mutat | A pluginja hiányzik a `plugins`-ból | Egy dokumentumtípus minden szerkesztőjének és előnézetének ugyanazokat a pluginokat add át. |
 | Egy blokk hiányzik a `Preview`-ból | A pluginjának nincs `preview`-ja | Adj a pluginnak `preview`-t (a mellékelt pluginoknak van alapértelmezett), vagy rendereld a blokkot a saját megjelenítőddel. |
-| Egy plugin blokkja hiányzik az oldalról | Az előnézet más `plugins`-t kapott, vagy a kép azonosítója nincs a `media`-ban | Ugyanazt a pluginlistát és médiát használd a szerkesztőhöz és az előnézethez. |
+| Egy plugin blokkja hiányzik az oldalról | Az előnézet más `plugins`-t kapott | Ugyanazt a pluginlistát használd a szerkesztőhöz és az előnézethez. |
+| Egy képblokk semmit sem renderel | Az előnézete elutasítja a tárolt címet, vagy az alkalmazás saját keresése nem ismeri a tárolt azonosítót | Olyan címet tárolj, amelyet az előnézet elfogad (`http(s)` vagy az oldalon belüli); az azonosítókat a szerkesztőben és az oldalon ugyanabból az adatból oldd fel. |
 | Egy doboz nem tehető egy másik dobozba | A beágyazott szerkesztők egy szint mélyek | A tárolókat tartalomblokkok befogadására tervezd, ne más tárolókéra. |
 | Egy blokk nem érhető el egy tárolón belül | Az `accepts` vagy az alkalmazás `palette`-je kihagyja | Vedd fel a palettaazonosítót az `accepts`-be (vagy használd az `'md:*'`-ot az összes beépítetthez). |
 | Egy egyedi blokk kétszer jelenik meg | A séma nem kényszeríti ki a `unique`-ot | Ellenőrizd a szerveren, ha az alkalmazásod számít rá. |
-| A védett tartalom mindenkinek látszik | A `gate` csak megjelöli a blokkokat | Renderelés előtt vágd meg a dokumentumot a szerveren. |
 | `document is not defined` | A `toMarkdown` vagy a `toStored` SSR közben futott | Csak a böngészőben hívd őket. |
 | Egy propsból jövő szín vagy link elrontja az oldalt | A props felhasználói bemenet | Használd a `safeColor`-t, ellenőrizd a linkeket, és propsszal soha ne használj `{@html}`-t. |
 | Egy felülírt plugin elveszíti a blokkjait | Megváltozott a `type`-ja | Egy plugin szétterítésekor tartsd meg a `type`-ot. |

package/docs/hu/server-side.md

@@ -76,20 +76,3 @@ export const description = (doc: StoredBlock[]) => blocksToPlainText(doc).slice(
 ## Renderelés
 
 A `Preview` hagyományos Svelte-komponens, és szerveren is renderelhető; a mag renderelője és a mellékelt előnézetek nem használnak böngésző-API-kat. Csak a markdown-export útvonalnak (`toMarkdown`, `toStored`) kell a böngésző.
-
-## Védett tartalom
-
-Egy kapus blokk (egy `gate: true` beállítású plugin, például egy csak támogatóknak szóló elválasztó) csak annyit tesz, hogy az előnézet megjelöli az utána következő blokkokat. Hogy a védett részt elzárd azoktól az olvasóktól, akik nem láthatják, vágd el a dokumentumot a szerveren, mielőtt az oldalhoz érne:
-
-```ts
-import type { StoredBlock } from '@atom-forge/brickee/model';
-
-/** A dokumentum az első kapus blokkig, azt is beleértve, hozzáférés nélküli olvasóknak. */
-export function publicPart(doc: StoredBlock[], gateTypes: string[], canRead: boolean): StoredBlock[] {
-	if (canRead) return doc;
-	const at = doc.findIndex((b) => gateTypes.includes(b.type));
-	return at < 0 ? doc : doc.slice(0, at + 1);
-}
-```
-
-Hívd meg a kapus pluginjaid típusaival (például `['paywall']`) és az olvasó hozzáférésével. A hozzáférés nélküli olvasók a kapus blokkig látják a tartalmat, az előzetesével együtt; a hozzáféréssel rendelkezők a teljes dokumentumot kapják, és az előnézet megjelöli számukra a védett részt.

package/docs/hu/upgrading.md

@@ -6,11 +6,41 @@ Ez a fejezet azokat a változásokat sorolja fel, amelyek teendőt igényelhetne
 
 A tőled semmit nem igénylő változások – új exportok, javítások, dokumentációfrissítések – csak a változásnaplóban (`CHANGELOG.md`, a csomaggal együtt szállítva) szerepelnek.
 
-> **Egyelőre nincs szükség migrációra**
->
-> Az `@atom-forge/brickee`-nek még nem volt olyan kiadása, amely változtatást igényelt volna az azt használó kódban. Az alábbi szakasz csak azoknak az alkalmazásoknak szól, amelyek már azelőtt használták a szerkesztőt, hogy ebből a csomagból lett volna.
+## A 0.0.2-ről a 0.0.3-ra
 
-## A `block-editor` munkaterület-csomagról az Unreleased változatra
+### A szerkesztő `dist` mappájának Tailwind `@source`-nak kell lennie
+
+A szerkesztő saját stílusai scoped CSS-ből Tailwind-osztályokba (az `@atom-forge/ui` téma színeivel) és SCSS-be kerültek. A Tailwind 4 nem néz bele a `node_modules`-ba, így a csomagra mutató `@source` nélkül a szerkesztő sorai, menüi, mezősávja és táblázata elveszítik a kinézetüket. Az előnézetet ez nem érinti: a stílusai továbbra is a jelölésével utaznak.
+
+**Teendő:** abban a CSS-fájlban, ahol az `@atom-forge/ui`-t beállítod, vedd fel az `@source "../node_modules/@atom-forge/brickee/dist";` sort (az attól a fájltól vett útvonallal) az `@atom-forge/ui`-é mellé. A csak `Preview`-t mutató oldalakon nincs teendő.
+
+### A kapus blokkok megszűntek
+
+A tartalom védése (támogatói vagy fizetőfalas elválasztó) az alkalmazás fogalma, nem a szerkesztőé. Kikerült a `BlockPlugin.gate`, a `Preview` `markGated` propja, a „For supporters only” szakasza a `.supporters` és `.supporters-label` osztályokkal, valamint a magyar fordítás `For supporters only` szövege. A `Preview` mostantól minden kapott blokkot renderel. A `unique` marad.
+
+**Teendő:** töröld a `gate: true`-t a pluginodból és a `markGated`-et az előnézeteidből. Az elválasztód közönséges (egyedi) pluginblokk marad, így a tárolt dokumentumok továbbra is betöltődnek. Ahol a védett részt megjelölve mutattad, rendereld a dokumentumot magad két részben – `const at = doc.findIndex((b) => b.type === 'divider')`, majd `doc.slice(0, at + 1)` és `doc.slice(at + 1)` két `<Preview>`-ban, a saját jelölésedben –, és a hozzáférés nélküli olvasóknak továbbra is vágd le a védett részt, mielőtt az oldalra kerül. Az általad mutatott feliratokhoz adj saját fordítást.
+
+## A 0.0.1-ről a 0.0.2-re
+
+### A képek és a média már nem részei a csomagnak
+
+A csomag többé nem ismeri a kép fogalmát. Hogy egy blokk a kép URL-jét vagy egy azonosítót tárol, hogyan választja ki a felhasználó a képet, és hogyan lesz a tárolt értékből cím, azt az alkalmazás saját képpluginja dönti el (lásd [Képek](writing-plugins.md#képek)).
+
+| Eltávolítva | Mi volt |
+|---|---|
+| `kind: 'image'`, `kind: 'images'` | Mezőfajták, amelyek egy kiválasztott médiaelem azonosítóját (vagy azonosítóit) tárolták, a beépített képválasztó felugró ablakkal |
+| Az `Editor` és a `Preview` `media` propja | A képek, amelyek közül a blokkok választhattak, és amelyekre hivatkozhattak |
+| `provideMedia`, `useMedia`, `findMedia`, `MediaItem` | A média-kontextus, a keresője és a típusa |
+| A `toMarkdown` `media` beállítása | A `toMarkdown(blocks, { plugins, media })` helyett most `toMarkdown(blocks, { plugins })` |
+| `ctx.media` egy plugin `markdown(props, ctx)` függvényében | A `MarkdownContext` most `{ inner }` |
+
+A `PropField['kind']` most `'text' | 'textarea' | 'color' | 'select' | 'slider'`. A tárolt dokumentumokat ez nem érinti: egy blokk propsa megtartja, amit tárolt, az azonosítókat is.
+
+**Teendő:** a képpluginjaidban cseréld le az `image` és `images` mezőket saját kiválasztásra — egy gombra a plugin nézetében, amely megnyitja a médiaablakodat vagy egy feltöltést, és az eredményt a `props`-ba írja, vagy egy egyszerű `text` mezőre egy URL-hez —, és tartsd meg a prop-kulcsokat, hogy a tárolt dokumentumok továbbra is betöltődjenek. Töröld a `media` propot a szerkesztőidről és előnézeteidről, és a `media` beállítást a `toMarkdown`-hívásaidból. Ahol egy nézet, előnézet vagy `markdown` alak a `useMedia`, `findMedia` vagy `ctx.media` segítségével alakított címmé egy azonosítót, ott az alkalmazásod saját adatában keresd ki: az alkalmazásod egy moduljában, vagy egy saját Svelte-kontextusban, amelyet a szerkesztő és az előnézet fölött adsz meg (a `markdown` komponenseken kívül fut, ezért modulbeli adat kell neki). Ha továbbra is szükséged van rá, definiálj egy `MediaItem`-szerű típust az alkalmazásodban.
+
+## A `block-editor` munkaterület-csomagról a 0.0.1-es változatra
+
+Ez a szakasz csak azoknak az alkalmazásoknak szól, amelyek már azelőtt használták a szerkesztőt, hogy ebből a csomagból lett volna.
 
 A szerkesztő `block-editor` néven, egy alkalmazáson belüli munkaterület-csomagként indult. Ugyanazzal a tárolt alakkal költözött ide `@atom-forge/brickee` néven, így az elmentett dokumentumokat nem kell átalakítani. Az import-azonosítók megváltoztak, a plugin-kit a pluginok belépési pontjából átkerült a magba, az oldalspecifikus pluginok pedig az alkalmazásnál maradtak.