fika-editor 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matěj "lofcz" Štágl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# /fika/
+
+```
+      .--.   _,                                                                       ,_  .--.
+  .--;    \ /(_                                                                     , ,   _)\/    ;--.
+ /    '.   |   '-._    . ' .            __    __ _ _              __        . ' .    \_\-'   |  .'    \
+|       \  \    ,-.)  -= * =-          / /   / _(_) | ____ _     / /       -= * =-   (.-,   /  /       |
+ \ /\_   '. \((` .(    '/. '          / /   | |_| | |/ / _` |   / /         ' .\'    ).  ))/ .'   _/\ /
+  )\ /     \ )\  _/   _/             / /    |  _| |   < (_| |  / /              \_   \_  /( /     \ /(
+ /  \\    .-'   '--. /_\            /_/     |_| |_|_|\_\__,_| /_/               /_\ .--'   `-.    //  \
+|    \\_.' ,        \/||                                                        ||\/        , '._//    |
+\     \_.-';,_) _)'\ \||                                                        ||/ /`(_ (_,;`-._/     /
+ '.       /`\   (   '._/                                                        \_.'   )   /`\       .'
+   `\   .;  |  . '.                                                                  .' .  |  ;.   /`
+     ).'  )/|      \                                                                /      |\(  `.(
+     `    ` |  \|   |                                                              |   |/  | `    `
+             \  |   |                                                              |   |  /
+              '.|   |                                                              |   |.'
+                 \  '\__                                                        __/'  /
+                  `-._  '. _                                                _ .'  _.-`
+                     \`;-.` `._                                          _.` `.-;`/
+                      \ \ `'-._\                                        /_.-'` / /
+                       \ |                                                    | /
+                        \ )                                                  ( /
+                         \_\                                                /_/
+```
+Fairies by [Joan G. Stark](https://en.wikipedia.org/wiki/Joan_Stark)

package/docs/AGENTIC_BRIDGE.md

@@ -0,0 +1,521 @@
+# Fika Agentic Bridge
+
+Fika exposes a typed agentic bridge through `fika-editor/embed`. The bridge is for host agents that need deterministic CRUD over decks, slides, elements, animations, tables, charts, notes, search, and presentation state without reaching into Zustand internals.
+
+This document is the style guide for the bridge contract. The canonical command types are the registered `execute()` commands in `src/embed/agentic/createAgenticApi.ts`; typed domain methods are convenience wrappers over the same command model when a wrapper exists.
+
+## Public Surface
+
+The public controller keeps the legacy imperative methods:
+
+```ts
+controller.getDocument()
+controller.setDocument(document)
+controller.setTitle(title)
+controller.setLocale(locale)
+controller.enterPresentation()
+controller.exitPresentation()
+controller.destroy()
+```
+
+The agentic surface adds command execution, state, events, and domain wrappers:
+
+```ts
+controller.getState()
+controller.execute({ id: 'cmd_1', type: 'slides.create', payload: { slide } })
+controller.executeBatch(commands, { atomic: true })
+controller.canExecute(command)
+controller.subscribe(event => {})
+await controller.markdownToHtml(markdown)
+controller.docs()
+controller.domains()
+controller.describe(commandType)
+controller.guides(guideId?)
+
+controller.deck.*
+controller.slides.*
+controller.elements.*
+controller.element.*
+controller.animations.*
+controller.tables.*
+controller.charts.*
+controller.media.*
+controller.links.*
+controller.notes.*
+controller.sections.*
+controller.search.*
+controller.history.*
+controller.view.*
+controller.import.*
+controller.export.*
+```
+
+Use domain wrappers for common flows. Use `execute()` for command-only operations that are registered but do not yet have a wrapper method.
+
+## API Naming
+
+Command names use `domain.action` with lower-camel-case actions:
+
+```ts
+type FikaCommandType = `${string}.${string}`
+```
+
+Canonical domains are `deck`, `import`, `export`, `slides`, `elements`, `animations`, `tables`, `charts`, `notes`, `sections`, `search`, `history`, and `view`.
+
+Naming rules:
+
+- Use plural collection domains: `slides`, `elements`, `animations`, `tables`, `charts`, `notes`, `sections`.
+- Use singular state domains when there is only one target: `deck`, `history`, `view`.
+- Use `create`, `get`, `list`, `update`, `delete`, `duplicate`, `move`, `select`, and `reorder` for common CRUD and ordering operations.
+- Use `setX` when replacing a named property, for example `deck.setTitle`, `slides.setBackground`, `charts.setType`.
+- Use `applyX` when one payload is applied to multiple targets, for example `slides.applyBackground`.
+- Use `patch` only for broad document-level patching, currently `deck.patch`.
+- Use stable payload field names: `slideId`, `elementId`, `animationId`, `noteId`, `sectionId`, `toIndex`, `row`, `col`, `patch`, and `options`.
+- Keep command types stable. Add new behavior under a new `domain.action` rather than changing the meaning of an existing action.
+
+## Command Envelope
+
+Every executable command uses this JSON-serializable envelope:
+
+```ts
+interface FikaAgentCommand<TPayload = unknown> {
+  id?: string
+  type: FikaCommandType
+  payload?: TPayload
+  meta?: {
+    commit?: boolean
+    dryRun?: boolean
+    source?: 'agent' | 'host' | 'ui'
+    label?: string
+  }
+}
+```
+
+`id` is caller-owned and optional. Provide it when the host needs to correlate logs, events, retries, or a batch result. The bridge returns it as `commandId`; it does not use the command ID as a deck, slide, or element ID.
+
+`meta.source` and `meta.label` are descriptive metadata for hosts and future event consumers. `meta.commit` and `meta.dryRun` affect execution:
+
+- `commit: false` suppresses the per-command history snapshot.
+- `dryRun: true` runs validation through the handler, restores the prior document, returns `changed: false`, and does not increment `documentVersion`.
+- Batch-level `dryRun` overrides individual command dry runs for that batch.
+
+## Result Contract
+
+Every `execute()` command and domain wrapper that mutates through the command layer resolves to a JSON-serializable result:
+
+```ts
+interface FikaCommandResult<TData = unknown> {
+  ok: boolean
+  commandId?: string
+  type: FikaCommandType
+  changed: boolean
+  documentVersion: number
+  snapshotId?: number
+  data?: TData
+  errors?: Array<{
+    code: string
+    message: string
+    path?: string
+    recoverable?: boolean
+  }>
+  warnings?: Array<{
+    code: string
+    message: string
+    path?: string
+    recoverable?: boolean
+  }>
+}
+```
+
+Result rules:
+
+- `ok: true` means the command handler completed.
+- `ok: false` means the command failed and document state was restored to its pre-command value.
+- `commandId` mirrors the incoming command `id`.
+- `type` always mirrors the incoming command `type`.
+- `changed` is true only when the command changed document or view state and was not a dry run.
+- `documentVersion` increments after successful, non-dry-run changed commands.
+- `snapshotId` is present only when that command created its own history snapshot.
+- `data` contains the command-specific return payload, usually the updated model object or current bridge state.
+- `errors` and `warnings` use machine-readable `code` plus human-readable `message`. `path` should point to the invalid payload field when available.
+
+Unsupported command types return `ok: false` with an error. `canExecute(command)` only checks whether the controller is alive and the command type is registered; use `dryRun` for payload-level validation.
+
+## Validation Rules
+
+Hosts should treat payloads as plain JSON. The bridge clones document data through JSON serialization in several paths, so functions, class instances, DOM nodes, and cyclic objects are invalid inputs.
+
+Reference validation:
+
+- `slideId`, `elementId`, `animationId`, and `noteId` must refer to existing objects unless the command creates that object.
+- `elements.*` commands search across slides when `slideId` is omitted, and search within `slideId` when it is provided.
+- Table commands require the target element to be `type: 'table'`.
+- Chart commands require the target element to be `type: 'chart'`.
+- Table cell commands require an existing `row` and `col`.
+- Note replies require the target note to exist on the target slide.
+
+Creation and ID rules:
+
+- Agents may provide deterministic object IDs in create payloads.
+- If an object ID is omitted, the bridge generates one with a type prefix such as `slide_`, `el_`, `anim_`, `note_`, `reply_`, `cell_`, or `group_`.
+- Agents must use the ID returned in `data` for later commands.
+- Do not reuse an ID for a different model object.
+
+Index rules:
+
+- Insert positions use `index`, `toIndex`, `rowIndex`, or `colIndex`.
+- Non-finite insert indexes append to the end.
+- Insert indexes are truncated to integers and clamped into the valid insertion range.
+- Selection and delete indexes are clamped into the existing range where the underlying model operation supports it.
+
+Content rules:
+
+- Element create payloads must include `element.type`.
+- Whole-document writes (`deck.set`, `deck.patch`, `import.json`, `import.fika`, and `import.pptxSafe`) require a JSON-serializable payload with a string `title` and a `slides` array before store state is touched.
+- Text-like content is stored as HTML where the model already expects HTML, for example text element `content`, shape `text.content`, slide `remark`, and note `content`.
+- Markdown flavor: `markdown-it` + `markdown-it-texmath` (KaTeX).
+- Use `content` / `text.setContent` for trusted HTML; use `markdown` / `text.setMarkdown` for Markdown.
+- Slide links should be validated against `slides.list()` before use.
+- DOM-dependent import/export paths remain outside the JSON bridge until they have been converted to a serializable document payload.
+
+## Snapshot Policy
+
+The bridge maintains a monotonic `documentVersion` and a separate `snapshotId`.
+
+- Successful changed commands create one history snapshot by default.
+- Pass `meta: { commit: false }` to suppress a command snapshot.
+- `executeBatch()` runs child commands with `commit: false`, increments `documentVersion` once, and commits one batch snapshot at the end when any child changed state.
+- Batch execution is atomic by default. Any failure restores the pre-batch runtime state, marks already-run changed results with a `BatchRolledBack` warning, and returns `BatchSkipped` errors for commands that were not run.
+- Passing `{ atomic: false }` keeps successful child changes, rolls back only the failed command, continues later commands, and returns the mixed success/failure result list for the caller to inspect.
+- Passing `{ commit: false }` to `executeBatch()` suppresses the final batch snapshot.
+- Passing `{ dryRun: true }` lets commands validate against the staged batch state, then restores the pre-batch runtime state, returns `changed: false`, and creates no snapshot.
+- `history.commit`, `history.undo`, and `history.redo` are command-layer operations and return bridge state.
+
+Events emitted through `subscribe()` include `documentChanged`, `selectionChanged`, `commandApplied`, `commandFailed`, and `destroyed`. Command events include the command envelope and result when available.
+
+## Examples
+
+Create a slide and text element in one atomic snapshot using deterministic IDs:
+
+```ts
+const results = await controller.executeBatch([
+  {
+    id: 'cmd_create_intro_slide',
+    type: 'slides.create',
+    payload: {
+      slide: {
+        id: 'slide_intro',
+        elements: [],
+        background: { type: 'solid', color: '#fff' },
+      },
+      select: true,
+    },
+  },
+  {
+    id: 'cmd_create_intro_title',
+    type: 'elements.create',
+    payload: {
+      slideId: 'slide_intro',
+      element: {
+        id: 'el_intro_title',
+        type: 'text',
+        left: 80,
+        top: 80,
+        width: 500,
+        height: 80,
+        rotate: 0,
+        content: '<p>Hello from agent</p>',
+        defaultFontName: '',
+        defaultColor: '#111111',
+      },
+      select: true,
+    },
+  },
+], { atomic: true })
+
+if (!results.every(result => result.ok)) {
+  console.error(results.find(result => !result.ok)?.errors)
+}
+```
+
+Validate a risky table edit without changing the deck:
+
+```ts
+const dryRun = await controller.execute({
+  id: 'cmd_validate_table_cell',
+  type: 'tables.setCell',
+  payload: {
+    elementId: 'table_fixture',
+    row: 0,
+    col: 1,
+    patch: { text: 'Updated' },
+  },
+  meta: { dryRun: true },
+})
+
+if (dryRun.ok) {
+  await controller.execute({
+    id: 'cmd_apply_table_cell',
+    type: 'tables.setCell',
+    payload: {
+      elementId: 'table_fixture',
+      row: 0,
+      col: 1,
+      patch: { text: 'Updated' },
+    },
+  })
+}
+```
+
+Subscribe to command failures:
+
+```ts
+const unsubscribe = controller.subscribe(event => {
+  if (event.type === 'commandFailed') {
+    console.error(event.result?.commandId, event.result?.errors)
+  }
+})
+```
+
+## Coverage Matrix
+
+| Model area | Registered commands | Convenience surface | Notes |
+| --- | --- | --- | --- |
+| Deck/document | `deck.get`, `deck.set`, `deck.patch`, `deck.setTitle`, `deck.setTheme`, `deck.setViewport`, `deck.setTemplates`, `import.json`, `import.fika`, `import.pptxSafe`, `export.json` | `deck.*`, `import.*`, `export.json()` | Import commands replace the deck from a data-safe document payload. |
+| Slides | `slides.list`, `slides.get`, `slides.create`, `slides.update`, `slides.delete`, `slides.duplicate`, `slides.move`, `slides.select`, `slides.setBackground`, `slides.applyBackground`, `slides.setTransition`, `slides.setRemark` | `slides.*` | `slides.applyBackground` is command-only in the current runtime. |
+| Elements | `elements.list`, `elements.get`, `elements.create`, `elements.update`, `elements.delete`, `elements.reorder`, `elements.select`, `elements.group`, `elements.ungroup`, `elements.lock`, `elements.hide`, `elements.setLink` | `elements.*`, `element.*`, `links.*` | Subtype and link helpers map to `elements.update` or `elements.setLink`. |
+| Media assets | `media.resolveAsset`, `media.setImageSource`, `media.setVideoSource`, `media.setAudioSource` | `media.*` | Accepts JSON-safe media assets or raw `src` strings. Video and audio ext fields are inferred when possible. |
+| Animations | `animations.list`, `animations.catalog`, `animations.create`, `animations.update`, `animations.delete`, `animations.reorder` | `animations.*` | `animations.catalog` is command-only in the current runtime. |
+| Tables | `tables.update`, `tables.setCell`, `tables.setCellStyle`, `tables.insertRow`, `tables.deleteRow`, `tables.insertColumn`, `tables.deleteColumn`, `tables.mergeCells`, `tables.splitCell` | `tables.*` | `tables.mergeCells` and `tables.splitCell` are command-only in the current runtime. |
+| Charts | `charts.update`, `charts.setType`, `charts.setData`, `charts.setLabels`, `charts.setLegends`, `charts.setSeries`, `charts.setOptions` | `charts.*` | Label, legend, and series helpers are command-only in the current runtime. |
+| Notes/comments | `notes.create`, `notes.update`, `notes.delete`, `notes.reply` | `notes.*` | `notes.list` is a direct read helper, not a registered command. |
+| Sections | `sections.set`, `sections.clear`, `sections.rename`, `sections.assignRange` | `sections.*` | `sections.list` is a direct read helper. `rename` and `assignRange` are command-only in the current runtime. |
+| Search | `search.find`, `search.replace` | `search.*` | Finds and replaces text element content, shape text content, and table cell text. |
+| View and selection | `view.setZoom`, `view.enterPresentation`, `view.exitPresentation`, `view.setLocale`, `slides.select`, `elements.select`, `elements.hide` | `view.*`, `slides.select`, `elements.select`, `elements.hide` | View commands return `FikaBridgeState`. |
+| History | `history.commit`, `history.undo`, `history.redo` | `history.*` | Undo and redo update `documentVersion` and return bridge state. |
+
+## Search And Replace
+
+`controller.search.find(query, options)` scans `text.content`, `shape.text.content`, and table cell `text` fields. `controller.search.replace(query, replacement, options, meta)` updates the same fields and returns only the matches it replaced. Both methods support `{ caseSensitive, regex }`; replace also supports `{ replaceAll }`, which defaults to replacing the first match.
+
+Both methods return `{ count, results }`, where each result includes `slideId`, `elementId`, `elementType`, `path`, `match`, `start`, `end`, and table cell `row`/`col` when applicable.
+
+## Media Asset Contract
+
+Media inputs must be JSON-safe. Hosts should resolve `File`, `Blob`, `ArrayBuffer`, upload handles, or private storage references before calling the bridge, then pass either a raw source string or a plain asset object:
+
+```ts
+type FikaMediaAssetInput = string | {
+  id?: string
+  kind?: 'image' | 'video' | 'audio'
+  src: string
+  ext?: string
+  mimeType?: string
+  filename?: string
+  title?: string
+  width?: number
+  height?: number
+  size?: number
+  poster?: string
+  metadata?: Record<string, unknown>
+}
+```
+
+`src` is the playable/renderable URL or data URL. The bridge does not fetch or upload media; it only normalizes the contract and writes element fields. `controller.media.resolveAsset(asset, kind)` returns the normalized asset without mutating the deck.
+
+The helper layer infers `mimeType` from data URLs and common file extensions, and infers `ext` from `mimeType` or URL/filename extensions. `media.setVideoSource` and `media.setAudioSource` copy the inferred `ext` into the Fika element when the caller did not provide an explicit patch ext.
+
+## Import Boundary
+
+The agentic bridge imports documents only after data has been reduced to a JSON-safe deck payload:
+
+```ts
+await controller.import.json(document)
+await controller.import.json(document, { mode: 'append', source: 'host' })
+await controller.importPptx(file, { mode: 'replace', confirm: false })
+
+await controller.execute({ type: 'import.json', payload: { document } })
+await controller.execute({ type: 'import.json', payload: { document, mode: 'append' } })
+await controller.execute({ type: 'import.fika', payload: { document } })
+await controller.execute({ type: 'import.pptxSafe', payload: { document } })
+```
+
+`import.json` is the canonical JSON bridge path. `import.fika` is for an already-decoded native `.fika` payload, and `import.pptxSafe` is for PPTX content that a trusted UI or host importer has already converted into a serializable deck payload. File-menu PPTX/JSON import replaces a 0–1 slide deck immediately and asks before replacing a longer deck; pass `mode: 'append'` or `confirm: false` on the controller to override that.
+
+Raw `.fika` decryption, raw PPTX parsing, `File` / `ArrayBuffer` reads, DOM parsing, media blob extraction, and other DOM-heavy import work stay outside the agentic JSON bridge. Do not send those boundaries through `controller.execute()` unless the result is already data-safe.
+
+## Host Safety Rules
+
+- Use commands or domain methods, not Zustand stores.
+- Prefer deterministic IDs for multi-command batches.
+- Use returned IDs after every create command.
+- Use `canExecute()` to reject unsupported command types early.
+- Use `meta.dryRun` to validate payload shape and references before risky edits.
+- Keep command batches small enough that a failed result can be inspected and retried by command ID.
+- Use `deck.set`, `deck.patch`, `import.json`, `import.fika`, or `import.pptxSafe` for whole-document writes so title/slides validation and JSON cloning happen before mutation.
+- Convert raw `.fika` and PPTX imports to a data-safe document before calling the agentic import APIs.
+- Treat `controller.export.json()` as the stable serializable export path for host-side persistence.
+
+## sciobot-next Usage Examples
+
+Use `controller.execute()` when sciobot represents an agent action as JSON:
+
+```ts
+import type { FikaAgentCommand } from 'fika-editor/embed'
+
+const command: FikaAgentCommand = {
+  type: 'deck.setTitle',
+  payload: { title: 'Cell Biology Review' },
+  meta: { source: 'agent', label: 'Rename generated deck' },
+}
+
+const capability = controller.canExecute(command)
+if (!capability.ok) throw new Error(capability.reason)
+
+const result = await controller.execute(command)
+if (!result.ok) {
+  reportAgentBridgeError(result.errors)
+}
+```
+
+Use domain APIs when the React host already has a `FikaController` instance and wants typed helper methods:
+
+```ts
+const slide = await controller.slides.create({
+  select: true,
+  slide: {
+    elements: [],
+    background: { type: 'solid', color: '#fff' },
+  },
+}, { source: 'agent', label: 'Create sciobot slide' })
+
+if (!slide.ok || !slide.data) return
+
+const text = await controller.elements.create({
+  slideId: slide.data.id,
+  element: {
+    type: 'text',
+    left: 72,
+    top: 72,
+    width: 640,
+    height: 120,
+    rotate: 0,
+    content: '<p>Learning objective</p>',
+    defaultFontName: '',
+    defaultColor: '#111',
+  },
+})
+
+if (text.ok && text.data) {
+  await controller.element.text(text.data.id, { content: '<p>Explain mitosis in five steps</p>' }, { slideId: slide.data.id })
+  await controller.links.set(text.data.id, { type: 'web', target: 'https://sciobot.app' }, { slideId: slide.data.id })
+}
+```
+
+Domain helpers cover specialized model areas without requiring store access:
+
+```ts
+await controller.tables.setCell(tableElementId, 0, 1, { text: 'Hypothesis' }, { slideId })
+await controller.charts.setData(chartElementId, {
+  labels: ['Before', 'After'],
+  legends: ['Class average'],
+  series: [[62, 81]],
+}, { slideId })
+await controller.media.setImageSource(imageElementId, '/fika-assets/imgs/example.png', { fixedRatio: true }, { slideId })
+await controller.slides.setRemark(slideId, '<p>Ask students to compare both bars.</p>')
+```
+
+Use `subscribe()` to connect Fika events to sciobot persistence, telemetry, or active selection state:
+
+```ts
+const unsubscribe = controller.subscribe(event => {
+  if (event.type === 'documentChanged') {
+    queueAutosave(controller.export.json())
+  }
+
+  if (event.type === 'selectionChanged') {
+    syncAgentSelection(event.data)
+  }
+
+  if (event.type === 'commandFailed') {
+    reportAgentBridgeError(event.result?.errors)
+  }
+})
+
+// Call before unmounting or replacing the controller.
+unsubscribe()
+```
+
+Use `executeBatch()` when one agent instruction expands to multiple bridge commands and should produce one undo step:
+
+```ts
+const results = await controller.executeBatch([
+  { type: 'slides.select', payload: { slideIdOrIndex: slideId } },
+  { type: 'slides.setBackground', payload: { slideId, background: { type: 'solid', color: '#f8fafc' } } },
+  {
+    type: 'elements.update',
+    payload: {
+      slideId,
+      elementId: [titleElementId, bodyElementId],
+      patch: { defaultColor: '#0f172a' },
+    },
+  },
+], { atomic: true })
+
+const failed = results.find(result => !result.ok)
+if (failed) reportAgentBridgeError(failed.errors)
+```
+
+The bridge does not load styles or static assets. The React host must load `fika-embed.css` with a `<link>` from the same `assetBaseUrl` used for `mocks/` and `imgs/`; do not import the CSS into the sciobot Vite/PostCSS pipeline. See [`EMBED.md`](./EMBED.md) for the React loader example and production copy constraints.
+
+## Migration Guide
+
+Keep legacy document calls at persistence boundaries:
+
+```ts
+controller.setDocument(await loadPresentationDocument(id))
+await savePresentationDocument(controller.getDocument())
+```
+
+Migrate in-editor agent edits from whole-document replacement to commands or domain APIs:
+
+```ts
+// Legacy: replace the complete document after changing one field.
+const document = controller.getDocument()
+controller.setDocument({
+  ...document,
+  title: 'Generated lesson',
+})
+
+// Agentic: mutate only the intended field and get a result.
+await controller.deck.setTitle('Generated lesson', { source: 'agent' })
+```
+
+```ts
+// Legacy: create a slide by appending to document.slides.
+const before = controller.getDocument()
+controller.setDocument({
+  ...before,
+  slides: [...before.slides, generatedSlide],
+})
+
+// Agentic: create through the bridge and use the returned ID.
+const created = await controller.slides.create({
+  slide: { ...generatedSlide, id: undefined },
+  select: true,
+})
+if (created.ok && created.data) {
+  await controller.slides.setRemark(created.data.id, '<p>Generated by sciobot</p>')
+}
+```
+
+```ts
+// Legacy: save after every small mutation.
+controller.setDocument(nextDocument)
+await savePresentationDocument(controller.getDocument())
+
+// Agentic: batch related mutations, then autosave from documentChanged.
+await controller.executeBatch(commands, { atomic: true })
+```
+
+Use `controller.export.json()` for a synchronous serializable snapshot. Use `controller.import.json(document)`, `controller.execute({ type: 'import.json', payload: { document } })`, or `controller.execute({ type: 'export.json' })` when sciobot needs command results for whole-document import/export.

package/docs/EMBED.md

@@ -0,0 +1,408 @@
+# Embedding Fika in sciobot-next (React)
+
+Fika ships as an **ESM library** (`fika-editor/embed`), not an iframe. React and React DOM are **peer dependencies** (`>19.2`) — the host must install them and the embed imports the host copy. The standalone demo app bundles its own React.
+
+## Build the embed bundle
+
+```bash
+cd Fika
+npm install
+npm run build:embed
+```
+
+Outputs:
+
+| File | Purpose |
+|------|---------|
+| `dist/embed/fika-embed.js` | ESM entry — `mountFika`, `unmountFika` |
+| `dist/embed/fika-embed.css` | All styles (load via `<link>` from `assetBaseUrl`, not bundled in React) |
+| `dist/embed/mocks/`, `fonts/` | Optional demo mocks and runtime fonts |
+
+## React usage
+
+```tsx
+import { useEffect, useRef } from 'react'
+import { mountFika, type FikaController } from 'fika-editor/embed'
+
+const assetBase = import.meta.env.VITE_FIKA_ASSET_BASE ?? '/fika-assets'
+
+export function FikaEditor({ locale }: { locale: 'cs' | 'en' | 'sk' | 'pl' }) {
+  const hostRef = useRef<HTMLDivElement>(null)
+  const controllerRef = useRef<FikaController | null>(null)
+
+  useEffect(() => {
+    const link = document.createElement('link')
+    link.rel = 'stylesheet'
+    link.href = `${assetBase}/fika-embed.css`
+    document.head.appendChild(link)
+    return () => link.remove()
+  }, [])
+
+  useEffect(() => {
+    const el = hostRef.current
+    if (!el) return
+
+    let cancelled = false
+
+    void mountFika(el, {
+      locale,
+      loadMockOnEmpty: true,
+      assetBaseUrl: import.meta.env.VITE_FIKA_ASSET_BASE ?? '/fika-assets',
+      onChange: (doc) => console.log('deck changed', doc.title),
+      onPresentationModeChange: (active) => console.log('presentation mode', active),
+    }).then(({ controller }) => {
+      if (cancelled) {
+        controller.destroy()
+        return
+      }
+      controllerRef.current = controller
+    })
+
+    return () => {
+      cancelled = true
+      controllerRef.current?.destroy()
+      controllerRef.current = null
+    }
+  }, [locale])
+
+  return <div ref={hostRef} className="h-full min-h-0 w-full" />
+}
+```
+
+## Imperative API (`FikaController`)
+
+| Method | Description |
+|--------|-------------|
+| `getDocument()` | `{ title, slides, theme, viewport }` JSON snapshot |
+| `setDocument(doc)` | Replace deck (applies `viewport` when present) |
+| `setTitle(title)` | Update title only |
+| `setLocale(locale)` | `cs` / `en` / `sk` / `pl` + reload i18n namespaces |
+| `enterPresentation()` | Full-screen slide show |
+| `exitPresentation()` | Back to editor |
+| `export.json()` | Serializable `{ title, slides, theme }` snapshot for agent/host persistence |
+| `importPptx(data, options?)` | Parse a `.pptx` file into the editor. Default: replace, no confirm. `{ mode: 'append' }` inserts; `{ confirm: true }` asks before replacing a multi-slide deck. |
+| `destroy()` | Unmount the editor and clear the host |
+
+The controller also exposes the agentic bridge documented in [`AGENTIC_BRIDGE.md`](./AGENTIC_BRIDGE.md). Use the legacy document methods for whole-deck load/save boundaries, and use the bridge for sciobot agent edits inside an already-mounted editor.
+
+### Agent command execution
+
+`controller.execute()` accepts a typed `domain.action` command. This is useful when the agent runtime stores commands as JSON or streams tool calls from sciobot:
+
+```ts
+const result = await controller.execute({
+  id: crypto.randomUUID(),
+  type: 'slides.create',
+  payload: {
+    select: true,
+    slide: {
+      elements: [],
+      background: { type: 'solid', color: '#fff' },
+    },
+  },
+  meta: { source: 'agent', label: 'Create generated slide' },
+})
+
+if (!result.ok) {
+  throw new Error(result.errors?.map(error => error.message).join('\n') || 'Fika command failed')
+}
+```
+
+### Domain API helpers
+
+For React code that is already coupled to `FikaController`, prefer the domain helpers. They keep command payloads typed while returning the same `FikaCommandResult` shape:
+
+```ts
+const createSlide = await controller.slides.create({
+  select: true,
+  slide: {
+    elements: [],
+    background: { type: 'solid', color: '#fff' },
+  },
+}, { source: 'agent', label: 'Create lesson slide' })
+
+if (!createSlide.ok || !createSlide.data) return
+
+await controller.deck.setTitle('Generated sciobot presentation')
+
+const createTitle = await controller.elements.create({
+  slideId: createSlide.data.id,
+  element: {
+    type: 'text',
+    left: 80,
+    top: 80,
+    width: 640,
+    height: 96,
+    rotate: 0,
+    content: '<p>Generated by sciobot</p>',
+    defaultFontName: '',
+    defaultColor: '#111',
+  },
+})
+
+if (createTitle.ok && createTitle.data) {
+  await controller.links.set(createTitle.data.id, { type: 'web', target: 'https://sciobot.app' })
+  await controller.elements.select(createTitle.data.id)
+}
+
+await controller.slides.setRemark(createSlide.data.id, '<p>Teacher notes from the sciobot agent</p>')
+```
+
+### Bridge subscriptions
+
+Subscribe once when the controller is mounted, then unsubscribe before replacing or destroying it. `documentChanged` is the best signal for persistence, while `commandFailed` is the best signal for agent telemetry:
+
+```tsx
+useEffect(() => {
+  const controller = controllerRef.current
+  if (!controller) return
+
+  return controller.subscribe(event => {
+    if (event.type === 'documentChanged') {
+      void savePresentationDraft(event.data)
+    }
+
+    if (event.type === 'commandFailed') {
+      console.warn('Fika command failed', event.command, event.result?.errors)
+    }
+  })
+}, [controllerRef.current])
+```
+
+### Batch edits
+
+For agent workflows, prefer `executeBatch()` when multiple edits should be one undo step. Batch commands run with intermediate `commit: false` and commit once at the end unless `{ commit: false }` is passed:
+
+```ts
+const slideId = controller.slides.get()?.id
+if (!slideId) return
+
+const results = await controller.executeBatch([
+  { type: 'slides.select', payload: { slideIdOrIndex: slideId } },
+  {
+    type: 'elements.create',
+    payload: {
+      slideId,
+      element: {
+        type: 'text',
+        left: 80,
+        top: 80,
+        width: 520,
+        height: 96,
+        rotate: 0,
+        content: '<p>Agent summary</p>',
+        defaultFontName: '',
+        defaultColor: '#111',
+      },
+      select: true,
+    },
+  },
+  { type: 'slides.setRemark', payload: { slideId, remark: '<p>Notes</p>' } },
+], { atomic: true })
+
+const failed = results.find(result => !result.ok)
+if (failed) console.error(failed.errors)
+```
+
+Speaker remarks are stored as HTML strings. Use `controller.slides.getRemark(slideId)` or the `slides.getRemark` command to read them, and `controller.slides.setRemark(slideId, html)` or `slides.setRemark` to write them; successful writes return the updated slide in `result.data`.
+
+### Export Boundary
+
+The embed controller exposes JSON export only:
+
+```ts
+const document = controller.export.json()
+const result = await controller.execute<FikaDocument>({ type: 'export.json' })
+```
+
+`export.json()` and the `export.json` command return the serializable `FikaDocument` model and do not require the editor DOM. PPTX export depends on pptxgenjs and in-browser media inlining, so it stays on the editor export dialog rather than the agentic bridge. Hosts that need a PPTX file should drive Fika's export UI in a browser context or add a dedicated DOM-aware integration boundary.
+
+### Export dialog formats
+
+The export dialog offers native PPTX and JSON only. Hosts can hide either format via `exportTabs`; omitted keys stay enabled.
+
+```ts
+await mountFika(host, {
+  exportTabs: {
+    pptx: true,
+    json: false,
+  },
+})
+```
+
+When only one format is enabled, the dialog shows a single download card for that format.
+
+### Locale switcher
+
+The editor header's right cluster can show a locale button (`EN` / `CS` / `SK` / `PL`). It is **off by default** — embedding hosts usually drive locale via `mountFika({ locale })` or `controller.setLocale()`. Pass `showLocaleSwitcher: true` to enable it. The standalone demo turns it on from `App.tsx`.
+
+```ts
+await mountFika(host, {
+  locale: 'cs',
+  showLocaleSwitcher: true,
+})
+```
+
+### Export media resolver (CORS)
+
+Third-party image hosts often allow `<img>` display but block browser `fetch`/XHR (no `Access-Control-Allow-Origin`). PPTX export needs the bytes, so hosts can pass `exportMediaResolver` — typically a same-origin proxy that returns a `data:` URL:
+
+```ts
+await mountFika(host, {
+  exportMediaResolver: async (url) => {
+    const res = await fetch('/functions/v1/media-fetch', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', /* auth */ },
+      body: JSON.stringify({ url }),
+    })
+    if (!res.ok) return null
+    // … blob → data URL
+    return dataUrl
+  },
+})
+```
+
+Direct fetch is tried first; the resolver runs only on failure.
+
+### Media uploads
+
+The toolbar **Media** action (images, video, and audio) opens a local-file picker. Pexels / remote galleries are not used. Without a host `upload` callback, images become data URLs and audio/video become blob URLs — fine for demos, not for persistence.
+
+Pass `media` to `mountFika()` for production:
+
+```ts
+import { mountFika, createFikaMediaUploader } from 'fika-editor/embed'
+
+await mountFika(host, {
+  media: {
+    constraints: {
+      maxFiles: 12,
+      maxFileSize: {
+        image: 20 * 1024 * 1024,
+        audio: 50 * 1024 * 1024,
+        video: 200 * 1024 * 1024,
+      },
+      kinds: ['image', 'video', 'audio'],
+      // Optional extra allowlists:
+      // mimeTypes: ['image/png', 'image/jpeg', 'video/mp4'],
+      // extensions: ['png', 'jpg', 'jpeg', 'mp4', 'mp3'],
+      // accept: 'image/*,video/*,audio/*',
+    },
+    concurrency: 3,
+    upload: createFikaMediaUploader({
+      url: '/api/media',
+      fieldName: 'file',
+      headers: () => ({ Authorization: `Bearer ${token}` }),
+      // Default parser accepts `{ url }`, `{ src }`, or `{ data: { url } }`.
+    }),
+  },
+})
+```
+
+`upload` can also be a custom function if you need signed URLs or a non-FormData protocol:
+
+```ts
+media: {
+  upload: async ({ file, kind, signal, onProgress }) => {
+    // … PUT to a signed URL, call onProgress({ loaded, total })
+    return { src: 'https://cdn.example.com/slide-asset.mp4', ext: 'mp4' }
+  },
+}
+```
+
+## sciobot-next wiring
+
+1. **package.json** — `"fika-editor": "^2.0.0"` after the package is published. During local development, sciobot's Vite config can fall back to the sibling `../Fika/dist/embed` build.
+2. After changing Fika locally, run `npm run build:embed` in Fika, then restart or refresh sciobot.
+3. **VITE_FIKA_ASSET_BASE** — URL prefix for `fika-embed.css`, `mocks/`, and `imgs/`:
+   - Dev: proxy `/fika-assets` → Fika `dist/embed` or `public/`
+   - Prod: copy `dist/embed/{fika-embed.css,mocks,imgs}` into sciobot `public/fika-assets/`
+4. **Locale** — pass sciobot `Locales`; same union as typesafe-i18n in both apps.
+5. **Vite** — do not pre-bundle `fika-editor/embed` into the host app (keep the embed as its own chunk):
+
+```ts
+// vite.config.ts (sciobot-next)
+resolve: {
+  alias: {
+    'fika-editor/embed': path.resolve(__dirname, '../Fika/dist/embed/fika-embed.js'),
+  },
+},
+optimizeDeps: {
+  exclude: ['fika-editor/embed'],
+},
+```
+
+### CSS asset loading constraints
+
+Load `fika-embed.css` as a plain asset from the same `assetBaseUrl` used for mocks and images:
+
+```tsx
+useEffect(() => {
+  const href = `${assetBase}/fika-embed.css`
+  if (document.querySelector(`link[data-fika-embed-css][href="${href}"]`)) return
+
+  const link = document.createElement('link')
+  link.rel = 'stylesheet'
+  link.href = href
+  link.dataset.fikaEmbedCss = 'true'
+  document.head.appendChild(link)
+
+  return () => {
+    document.querySelector(`link[data-fika-embed-css][href="${href}"]`)?.remove()
+  }
+}, [])
+```
+
+Do not `import 'fika-editor/embed.css'` in React. The CSS is large and should not enter the host PostCSS/Tailwind pipeline.
+
+### Migrating legacy document calls
+
+Existing save/load code can keep using `getDocument()` and `setDocument()` at persistence boundaries:
+
+```ts
+await savePresentation(controller.getDocument())
+
+const document = await loadPresentation(id)
+controller.setDocument(document)
+```
+
+Agent edits should migrate to bridge commands so sciobot can observe command results, failures, and undo snapshots:
+
+```ts
+// Legacy: replace the whole document to add a slide.
+const document = controller.getDocument()
+controller.setDocument({
+  ...document,
+  slides: [...document.slides, generatedSlide],
+})
+
+// Agentic: create the slide through the bridge.
+await controller.slides.create({
+  slide: {
+    ...generatedSlide,
+    id: undefined,
+  },
+  select: true,
+})
+```
+
+Use `controller.export.json()`, `controller.import.json(document)`, or `controller.execute({ type: 'import.json', payload: { document } })` when the persistence layer wants command results for whole-document operations. Pass `{ mode: 'append' }` on import meta/payload to insert slides instead of replacing; `{ confirm: false }` skips the replace dialog (the default on the controller).
+
+## Host CSS
+
+Load `fika-embed.css` as a standalone `<link>` (do not bundle it through the host toolchain). The embed root resets inherited host preflight — especially Tailwind's `html { line-height: 1.5 }` and `img { max-width: 100% }` — so slide text and media match the standalone demo.
+
+Persist `document.viewport` from `onChange` / `getDocument()` and pass it back on `mount` / `setDocument`. Without it, imported decks fall back to 1000×16:9 and elements overflow the slide box.
+
+## Why not iframe?
+
+- Shared imperative API for save/load with Supabase
+- Locale driven by sciobot zustand without postMessage
+- Single CSP / auth surface when both apps are same origin
+- Heavier initial JS, but one integrated surface for teachers
+
+## Future
+
+- `postMessage` optional bridge for cross-origin CDN hosting
+- Persist `FikaDocument` in `linked_materials` + `presentation` kind in workspace tabs
+- Split chunk / lazy `import('fika-editor/embed')` on first open of presentation tab

package/package.json

@@ -0,0 +1,174 @@
+{
+  "name": "fika-editor",
+  "version": "3.0.0",
+  "description": "Fika presentation editor embed bundle with a typed agentic bridge.",
+  "type": "module",
+  "main": "dist/embed/fika-embed.js",
+  "module": "dist/embed/fika-embed.js",
+  "types": "dist/types/embed/index.d.ts",
+  "files": [
+    "dist/embed",
+    "dist/types",
+    "docs/EMBED.md",
+    "docs/AGENTIC_BRIDGE.md",
+    "docs/RELEASE.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/embed/index.d.ts",
+      "import": "./dist/embed/fika-embed.js",
+      "default": "./dist/embed/fika-embed.js"
+    },
+    "./embed": {
+      "types": "./dist/types/embed/index.d.ts",
+      "import": "./dist/embed/fika-embed.js",
+      "default": "./dist/embed/fika-embed.js"
+    },
+    "./embed.css": {
+      "import": "./dist/embed/fika-embed.css",
+      "default": "./dist/embed/fika-embed.css"
+    },
+    "./agentic-manifest.json": "./dist/embed/agentic-manifest.json",
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=24 <25"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": [
+    "*.css",
+    "dist/embed/fika-embed.css"
+  ],
+  "scripts": {
+    "dev": "rsbuild dev",
+    "doctor": "react-doctor --no-telemetry",
+    "build": "run-p type-check \"build-only {@}\" --",
+    "build:embed": "node scripts/run-i18n.mjs --no-watch && npm run build:types && rsbuild build --config rsbuild.config.embed.ts && node scripts/scope-embed-css.mjs && node scripts/extract-embed-fonts.mjs && node scripts/copy-embed-public.mjs && node scripts/generate-agentic-manifest.mjs",
+    "agentic:manifest": "node scripts/generate-agentic-manifest.mjs",
+    "build:types": "node -e \"require('node:fs').rmSync('dist/types',{recursive:true,force:true})\" && tsc -p tsconfig.types.json && node scripts/rewrite-embed-types.mjs",
+    "preview": "rsbuild preview",
+    "build-only": "rsbuild build",
+    "type-check": "tsc -p tsconfig.app.json --noEmit --pretty false",
+    "lint": "eslint . --ext .js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --fix --ignore-path .gitignore",
+    "test:react-mount": "node scripts/check-react-mount.mjs",
+    "i18n": "node scripts/run-i18n.mjs",
+    "i18n:build": "node scripts/run-i18n.mjs --no-watch",
+    "test:agentic-bridge": "node scripts/check-agentic-bridge.mjs && node scripts/check-composition.mjs && node scripts/check-layout-robustness.mjs && node scripts/check-agent-text.mjs && node scripts/check-canvas-pointer.mjs && node scripts/check-canvas-zoom.mjs && node scripts/check-canvas-hit-test.mjs && node scripts/check-editor-caret.mjs && node scripts/check-text-selection.mjs && node scripts/check-import-apply.mjs && node scripts/check-job-progress.mjs && node scripts/check-element-order.mjs && node scripts/check-react-mount.mjs && node scripts/check-fn-utils.mjs && node scripts/check-snap.mjs",
+    "test:omml-export": "node scripts/e2e-math-export/omml-export.mjs",
+    "test:port-features": "node scripts/check-pptx-unit.mjs && node scripts/check-pptx-import-picture.mjs && node scripts/check-pptx-import-text.mjs && node scripts/check-pptx-text-fit.mjs && node scripts/check-text-fit-scale.mjs && node scripts/check-hyperlink-follow.mjs && node scripts/check-slide-code-utils.mjs && node scripts/check-latex-extract.mjs && node scripts/check-theme-file.mjs && node scripts/check-port-features.mjs && node scripts/check-code-highlight.mjs && node scripts/check-pptx-import-fidelity.mjs && node scripts/check-import-math-scrollbars.mjs && node scripts/check-text-contrast.mjs && node scripts/check-omml-run-style.mjs && node scripts/check-pptx-import-fonts.mjs",
+    "test:text-fit": "node scripts/check-text-fit-scale.mjs",
+    "test:text-fit:e2e": "node scripts/e2e-text-fit.mjs",
+    "test:import-fidelity": "node scripts/check-pptx-import-fidelity.mjs",
+    "test:import-fidelity:e2e": "bunx tsx --tsconfig tsconfig.app.json scripts/e2e-pptx-import-fidelity.mts",
+    "test:import-fidelity:all": "bun run test:import-fidelity && bun run test:import-fidelity:e2e",
+    "test:sb1-import": "node scripts/check-sb1-import.mjs",
+    "test:sb1-import:e2e": "node scripts/e2e-sb1-import.mjs",
+    "test:houby-import": "node scripts/check-pptx-import-fonts.mjs",
+    "test:houby-import:e2e": "node scripts/e2e-pptx-import-houby.mjs"
+  },
+  "author": "Matěj \"lofcz\" Štágl",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lofcz/fika.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lofcz/fika/issues"
+  },
+  "homepage": "https://github.com/lofcz/fika#readme",
+  "dependencies": {
+    "@chenglou/pretext": "^0.0.8",
+    "@codemirror/commands": "^6.10.4",
+    "@codemirror/lang-json": "^6.0.2",
+    "@codemirror/language": "^6.12.4",
+    "@codemirror/state": "^6.7.1",
+    "@codemirror/view": "^6.43.8",
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@lofcz/pptxgenjs": "^4.1.16",
+    "animate.css": "^4.1.1",
+    "buffer": "^6.0.3",
+    "clipboard": "^2.0.11",
+    "codemirror": "^6.0.2",
+    "crypto-js": "^4.2.0",
+    "dexie": "^4.4.4",
+    "dompurify": "^3.4.13",
+    "echarts": "^6.1.0",
+    "events": "^3.3.0",
+    "fast-average-color": "^9.5.2",
+    "file-saver": "^2.0.5",
+    "hfmath": "^0.0.2",
+    "html-to-image": "^1.11.13",
+    "immer": "^11.1.16",
+    "jszip": "^3.10.1",
+    "lucide-react": "^1.31.0",
+    "markdown-it": "^15.0.0",
+    "markdown-it-texmath": "^1.0.0",
+    "mathlive": "npm:@lofcz/mathlive@^0.110.2",
+    "mathml2omml": "^0.5.0",
+    "mermaid": "^11.16.1",
+    "mitt": "^3.0.1",
+    "nanoid": "^6.0.1",
+    "number-precision": "^1.6.0",
+    "overlayscrollbars": "^2.16.0",
+    "perfect-freehand": "^1.2.3",
+    "pptxtojson": "npm:@lofcz/pptxtojson@^2.2.5",
+    "prosemirror-commands": "^1.7.2",
+    "prosemirror-dropcursor": "^1.8.3",
+    "prosemirror-gapcursor": "^1.4.1",
+    "prosemirror-history": "^1.5.0",
+    "prosemirror-inputrules": "^1.5.1",
+    "prosemirror-keymap": "^1.2.3",
+    "prosemirror-model": "^1.25.11",
+    "prosemirror-schema-basic": "^1.2.4",
+    "prosemirror-schema-list": "^1.5.1",
+    "prosemirror-state": "^1.4.4",
+    "prosemirror-view": "^1.42.2",
+    "shiki": "^4.4.3",
+    "svg-pathdata": "^9.0.0",
+    "tinycolor2": "^1.6.0",
+    "tippy.js": "^6.3.7",
+    "txml": "^6.0.0",
+    "use-sync-external-store": "^1.6.0",
+    "wawoff2": "^2.0.1",
+    "zustand": "^5.0.15"
+  },
+  "peerDependencies": {
+    "react": ">19.2.0",
+    "react-dom": ">19.2.0"
+  },
+  "devDependencies": {
+    "@rsbuild/core": "^2.1.0",
+    "@rsbuild/plugin-node-polyfill": "^1.4.3",
+    "@rsbuild/plugin-react": "^2.1.0",
+    "@rsbuild/plugin-sass": "^2.0.1",
+    "@rushstack/eslint-patch": "^1.16.1",
+    "@types/crypto-js": "^4.2.1",
+    "@types/dompurify": "^3.2.0",
+    "@types/file-saver": "^2.0.7",
+    "@types/markdown-it": "^14.1.2",
+    "@types/node": "^26.2.0",
+    "@types/react": "^19.2.18",
+    "@types/react-dom": "^19.2.4",
+    "@types/tinycolor2": "^1.4.6",
+    "eslint": "^10.8.1",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "npm-run-all2": "^9.0.3",
+    "playwright": "^1.62.1",
+    "postcss": "^8.5.26",
+    "postcss-selector-parser": "^7.1.5",
+    "react": "^19.2.8",
+    "react-doctor": "^0.9.12",
+    "react-dom": "^19.2.8",
+    "react-scan": "^0.5.7",
+    "sass": "^1.100.0",
+    "typesafe-i18n": "npm:@lofcz/typesafe-i18n@5.27.4",
+    "typescript": "^7.0.2"
+  },
+  "allowScripts": {
+    "@parcel/watcher@2.5.6": true
+  }
+}