@plitzi/sdk-mcp 0.37.7 → 0.37.9

package/CHANGELOG.md

@@ -1,5 +1,272 @@
 # @plitzi/sdk-mcp
 
+## 0.37.9
+
+### Patch Changes
+
+- 3ae61a4: ## Components replace segments
+
+  - **What a component is:** a reusable block written once and placed anywhere as an instance. An edit to the component
+    is an edit to every instance.
+  - **Where it lives:** in the space document, as `schema.components`, one tree per component and never in
+    `schema.flat`. It is published, rolled back, copied by templates and exported with the space.
+  - **Props and slots:**
+    - A component declares props (`type`, `description`, `required`, `default`, `options`). An instance hands them in
+      as its own attributes, so templates and bindings reach them. Inside, they are read as `{{ props.<name> }}`.
+    - Slots are elements an instance fills; each child names its slot in `attributes.slot`.
+  - **A prop an instance leaves out prints nothing.** It is its `default`, or `null`. `props` is a settled source:
+    - `processTwig` takes `{ settled }` in place of `keepEmptyTokens: true`.
+    - Every other empty token is still kept for a later pass.
+    - `COMPONENT_PROPS_SOURCE` names the source.
+  - **Fixed: a flow in a list row or a component instance acts on its own copy.** A step's target resolves in the
+    replica the flow fired in first, then outwards. It used to reach whichever copy registered last.
+  - **Fixed: an instance's own `visible` hides it in preview.** The same goes for an element reference.
+  - **Fixed: a list row keeps its state with its record.** Rows are keyed by each record's unique `id`, so filtering no
+    longer moves one row's state onto another.
+  - **Closed scope:** inside, a component reads only its props and the globals. The validator, `lintSpace` and
+    `authorSpace` each refuse a read of the page around an instance. Components nest, and a cycle is refused.
+  - **Where to use them:**
+    - In code (`@plitzi/sdk-authoring`): `SpaceSpec.components` and `component(id, { props, children })`.
+      `specFromSpace` and `specToSource` read and write both.
+    - In the builder:
+      - a Components panel lists them, and an open component becomes the canvas;
+      - an element becomes a component with **Save as component**;
+      - in an instance's settings, an instance gets its props and slots, or is **detached** back into a copy.
+    - In the MCP: `upsertComponent` and `deleteComponent`. Element ops work inside a component through `pageRef`.
+  - **Schema helpers:** `@plitzi/sdk-schema` gains `addComponent`, `updateComponent`, `removeComponent`,
+    `detachInstance`, `renameElement`, `treeOf`, `flatMapOf` and `documentIds`.
+  - **GraphQL and live events:** `SpaceAddComponent`, `SpaceUpdateComponent`, `SpaceRemoveComponent` and
+    `SpaceDetachInstance`, each with a live event. History records a declaration change as a `component` entry.
+  - **Breaking: segments are removed.** This covers:
+    - `@plitzi/sdk-shared`'s segment types, queries, mutations, context and `SEGMENT_*` events;
+    - `referenceType: 'segment'`;
+    - the `Segments` builder module;
+    - `Space.segments` and the `Segment`/`Segments` queries;
+    - `CommonState.prevSchema`.
+  - **Breaking: `ElementLayout` and `LayoutBody` change shape.**
+    - `ElementLayout` is `{ slots, rootId, type }`; it was `{ containerId }`.
+    - `LayoutBody` takes `bodies` keyed by slot.
+    - `reference`'s `referenceContainer` attribute is removed.
+  - Guide: `docs/en/components.md`.
+
+  ## Functions ask for the time they need
+  - **What changes:** a task can ask for more CPU or wall time than the default with `limits`, in milliseconds. Example:
+    `limits: { cpuMs: 1000, wallMs: 20_000 }`. `defineFunctions({ limits })` asks it for every task and route at once,
+    and a task's own limits win over those.
+  - **What a run is given:** what it asked for, or the default (100 ms of CPU, 10 s) when it asked for nothing. Never
+    above the space's plan or the deployment's ceiling.
+  - **Deployment ceilings:** `functions.limits` sets them. `DEFAULT_FUNCTION_CEILINGS` covers each unset one, at 2 s of
+    CPU and 30 s.
+  - **Asking for more than the ceiling** is a problem when the functions are saved; it is never quietly cut down.
+  - **Manifest:** carries what each task asked for, and the builder shows it beside the task.
+
+  ## Functions answer under `/fn`, not `/api`
+
+  A space's routes are served at `/fn/<path>` (`FUNCTION_ROUTES_PREFIX`). `/api` is a slug a site wants for a page of its
+  own. A page under `/fn` is refused instead (`page-route-reserved`).
+
+  ## The builder's Functions panel
+
+  Rebuilt around the code. The panel reads `defineFunctions` as it is typed and writes into it, so the code stays the one
+  place a function is declared.
+
+  - **Layout:** the tasks, routes and files on the left, the code in the middle, the selected task on the right.
+  - **Live list:** tasks and routes are listed as the code declares them, including tasks imported from another file.
+    A task you have written but not saved says so. Tasks built by calling something are counted, and listed once saved.
+  - **Code and panel follow each other:** clicking a task or a route opens its file at its line. Putting the cursor inside
+    a task's code selects that task.
+  - **New task:** + in Tasks asks for its namespace, action and title. The task is written into `defineFunctions` with a
+    `run` to start from, in the file's own quotes, and the editor opens on it.
+  - **Time limit:** each task gets a slider from 100 ms to 1 s of CPU per run, with presets. The value is written into
+    the task as `limits: { cpuMs }`. "Use default" takes it out. `DEFAULT_FUNCTION_TIME_LIMITS` in
+    `@plitzi/sdk-shared/actions` is the default both the panel and the server use.
+  - **Test:** fills a task's params the way its step does, from their defaults: a select, a switch or text. JSON stays a
+    toggle away. With unsaved changes, the button reads "Save & run": it saves, then runs. If the save fails, it says why.
+  - **Header:** shows Saved, Unsaved (and in how many files) or the number of problems the last save found. ⌘S saves.
+    **Discard** asks first, then puts every file back to what was last saved, or back to nothing for functions never
+    saved. Removing the functions is a quiet button beside Save.
+  - **Problems:** clicking one opens its file at its line.
+  - **Editor:** each file has its own editor and undo history. Opening another file no longer marks the one you left as
+    changed. Before this, it could also write the newly opened file's text into the one you left. The cause was in
+    `@plitzi/plitzi-ui`'s CodeMirror, fixed in 1.6.25, which every package now depends on. That release also sets code
+    editors (several lines) in a monospaced face again. Long lines scroll inside the editor, and the line numbers stay
+    in place.
+
+  ## A space's own functions are their own category of steps
+
+  In the action editor's step picker, the space's own functions are listed under **Functions**, apart from the
+  platform's **Tasks**. The other headings now read Callbacks, Global callbacks and Utilities. The saved step is still a
+  `task` node.
+
+  - `@plitzi/sdk-server`: every registered task has an `origin`, `'deployment'` (shipped with the server or a native
+    function) or `'space'` (from the space's functions). `describeCatalog`, `/_action/catalog` and the builder's
+    `SpaceActionTasks` carry it (`ActionTaskDescriptor.origin`).
+  - `@plitzi/sdk-shared`: an `InteractionCallback` may name the `group` the picker lists it under.
+
+  ## Fixed: preview no longer breaks a builder that is embedded in a page
+
+  When the builder is mounted inside a Plitzi page (the platform's `/spaces/:id/update`), going to preview with a page
+  that has SEO turned on left the builder unstyled. The previewed page wrote its title and description through a head
+  manager of the builder's own, and that manager rewrote the host page's head, removing the builder's own stylesheet.
+
+  - `@plitzi/sdk-shared`: a new render setting, `ownsHead`, says whether the page may write the document head. It is on
+    by default (`DEFAULT_RENDER_SETTINGS`).
+  - `@plitzi/sdk-elements`: `Page` writes its SEO only where `ownsHead` is on.
+  - Builder: sets `ownsHead: false` for its canvas. A page drawn there is in a frame, and the document head is the
+    editor's. The canvas's own `HelmetProvider` is gone.
+
+  ## Fixed: the builder's plan usage panel shows the space being edited
+  - **The 404 is gone.** Opening Plan usage said "The account breakdown could not be read (The server answered 404.)".
+    The panel asked `/account/usage`, which went away when accounts became workspaces.
+  - **Only this space.** The panel listed every space of the workspace. It now reads `/spaces/:spaceId/usage`, which
+    now also answers the space's own `pages` (the heaviest ten), `pagesTotal` and `periodEndsAt`. The plan's ceilings
+    stay on top. Anyone who can edit the space can read it, including a guest of another workspace.
+  - **It scrolls.** A long breakdown scrolls inside the modal, where it used to overflow.
+  - **`getKeyDecoded(webKey, true)` reads the token's subject.** The function, in `@plitzi/sdk-shared`, looked for
+    `data.spaceId`, which space tokens no longer carry, so every space decoded as 0. The builder asked about space 0, and
+    the builder and the SDK kept every space's persisted state under the same key on a host. Pages served without a
+    `webKey` (SSR) still decode as 0, which is what their painted-state cookie is named after.
+
+  ## Fixed: a remote plugin in the builder reads the canvas it sits in
+
+  The builder carries its own copy of the Plitzi runtime. A remote plugin imports `@plitzi/plitzi-sdk`, which the page's
+  import map resolves to the SDK's copy. Each copy made its own React contexts, so on the builder's canvas a plugin read
+  none of the canvas's providers. In the builder embedded in Plitzi's site, it read the site around the builder instead:
+  the site's element as its own, the site's live mode (so it stayed interactive while being edited), and the site's store
+  and interactions.
+
+  - `@plitzi/sdk-shared` gains `sharedContext(name, default)`: a context made once per page and handed to every copy of
+    the runtime that asks for it.
+  - The runtime's contexts now go through it, so a provider from any copy reaches a consumer from any copy:
+    - `@plitzi/sdk-shared`: service, component, schema, network, theme scope, dev tools, builder.
+    - `@plitzi/sdk-elements`: element, element parent, layout body.
+    - interactions, plugins, event bridge, auth, variables and style.
+  - The store's contexts need `@plitzi/nexus` 1.4.0, which does the same. Every `@plitzi/*` package now asks for
+    `^1.4.0`, which is published.
+
+  ## The source of plugins and runtimes is kept on the space
+
+  What a plugin or a runtime is built from now goes up with it, so a space can be taken back out as a project
+  (`plitzi create --from`, below).
+
+  - `@plitzi/cli`:
+    - `plitzi pack plugin` writes the plugin's source beside its zip: every file of the project its elements import,
+      `import type` included, and the packages they need. `--source-root` names the project those paths are relative to.
+    - `plitzi upload plugin` and `plitzi runtime push` keep that source on the space, in its private bucket.
+    - `plitzi pack source` writes it to a file.
+    - A source that cannot be kept (a file outside the project, an undeclared package, a credential in the code) never
+      stops the upload or the push: they say why, and the artifact is kept built only.
+  - `@plitzi/sdk-shared/source`: the snapshot's format, the paths it may hold and the credential check, shared by the CLI
+    and the platform.
+
+  ## `plitzi create --from` and `plitzi pull`: a space on Plitzi as a project of your own
+
+  The way back from everything the CLI puts on Plitzi. `plitzi create my-board --from pizarra` writes a server project
+  holding what the space is made of, and runs it with nothing of Plitzi's: neither its servers nor its CDN. `plitzi pull`
+  keeps it in step with the space. See `docs/en/projects-from-spaces.md`.
+
+  - **What lands in the project:**
+    - its pages as authoring code;
+    - its server actions as `defineAction` code — JSON, with the reason said, for one that would not read back exactly;
+    - its plugins and runtime as the source they were uploaded from, and its functions;
+    - its files, downloaded into `public/`, with every CDN address rewritten to the project's.
+  - **`src/main.ts`** serves all of it, the runtime in the same process.
+  - **`.env`** gets a key made for the project's actions to sign with, and the names of the variables and credentials
+    the space had. Their values stay on Plitzi.
+  - **Who may run it:** the person must be signed in and able to change the space (owner, administrator or writer).
+  - **Plugins** are rebuilt against the project's SDK. One uploaded before sources were kept runs as it was built, from
+    `vendor/plugins/`, and the report says to upload it again.
+  - **The end of `create`** says what came across differently, including a space whose visitors sign in with Plitzi.
+  - `--source cloud` keeps the pages on Plitzi and runs the rest locally.
+  - **Any version:** `--environment` and `--revision` take out a published snapshot — its latest, or one revision pinned
+    — instead of the draft, with the source its plugins and runtime were built from then. A cloud project serves that
+    revision pinned.
+  - **`plitzi pull`** writes what changed on the space, keeps what changed in the project, and writes nothing when a
+    file changed on both — naming them, with `--force` to take the space's copy. It never touches `.env`, only adds to
+    `package.json`, and keeps `plitzi functions push` working from the project. It follows the version the project was
+    made from, and `--environment`/`--revision` move it.
+  - `@plitzi/sdk-authoring`:
+    - `actionSpecFromEntry` reads an action document back into its `defineAction` declaration, only when the round trip
+      is exact, and `actionToSource` writes it as a module.
+    - `defineAction` takes `limits`.
+    - `specToSource` takes `importExtension: '.ts'`, for split files that Node imports as they are.
+
+  ## The builder shows what a snapshot holds
+
+  **Make Snapshot** lists what it will freeze — pages, layouts and elements, server actions, connectors, functions, the
+  runtime and the plugins, each with whether its source is kept — and what no snapshot freezes: the space's files, its
+  variables and credentials. A space's components are part of its document, so they are frozen with its pages. **Publish Snapshot** lists what the chosen environment's snapshot holds.
+
+  ## Fixed: a space read from Plitzi kept its server elements
+  - **What happened:** a page server reading its space from Plitzi (`createCloudAdapters`) never ran an element's
+    `render` action, and a browser-rendered space ignored `loadStrategy`. The space's GraphQL answered neither
+    `runtime` nor `loadStrategy` of an element, nor the space's `rsc` settings.
+  - **Now:** the platform answers them, and the SDK, the builder and the cloud adapters ask for them.
+
+  ## A plugin the deployment registers is not looked for elsewhere
+
+  `@plitzi/sdk-server` used to fetch the manifest of every plugin the space lists on its CDN, even one the deployment
+  registers itself, and logged a warning when the CDN was out of reach. It now asks only for the ones it does not have.
+
+  ## Fixed: inline code in Markdown carries nothing of the syntax tree
+
+  A `markdown` element wrote every inline `` `code` `` as `<code node="[object Object]">`: `react-markdown` hands its
+  renderers the syntax-tree node as a prop, and the inline branch spread it onto the tag. Fixed in
+  `@plitzi/plitzi-ui` 1.6.26 (with a test), which every package now asks for.
+
+  ## Dev tools hear about the render run the page stopped waiting for
+
+  When a server element's action ran past the section's budget, the page was answered without it. The run ended a moment
+  later, after the page's runs had been sent, so the dev tools never showed the one run that needed debugging. It is now
+  told the moment the page stops waiting, as `aborted`, with the reason.
+
+  ## Fixed: a tab you come back to no longer loses its session
+  - **What happened:** a page left in another tab past its access token's life signed its visitor out on return. A
+    reload put them right back in.
+  - **Why:** the browser drops the cookie carrying the access token the moment the token expires, and the background
+    tab's renewal timer had not run. The first check on return was told `missing`, which the client took as no
+    session at all.
+  - **Now:** a `missing` refusal is renewed instead whenever the browser can still renew, meaning it holds a refresh
+    token or a session hint whose renewal window is open. The session ends only if that renewal fails.
+  - **Requests made in that moment:** `reportAuthFailure` now answers whether it renewed the session. A read refused
+    as the tab came back is asked again, once, once the session is renewed. This covers an api container's read and a
+    server section's refresh, so they no longer show a 401 that only a reload cleared.
+
+- Updated dependencies [3ae61a4]
+  - @plitzi/sdk-authoring@0.37.9
+  - @plitzi/sdk-elements@0.37.9
+  - @plitzi/sdk-interactions@0.37.9
+  - @plitzi/sdk-schema@0.37.9
+  - @plitzi/sdk-shared@0.37.9
+  - @plitzi/sdk-style@0.37.9
+  - @plitzi/plitzi-sdk@0.37.9
+  - @plitzi/sdk-server@0.37.9
+
+## 0.37.8
+
+### Patch Changes
+
+- 4d10e0a: ## Fixed: an api container could not read a file from a CDN
+
+  - **What happened:** the api container sent `Content-Type: application/json` on every request, including a GET with no
+    body to describe. That made every read a non-simple cross-origin request, so the browser asked the host's
+    permission first.
+  - **Who it hit:** hosts that allow plain cross-origin reads (GET and HEAD from any origin, the usual CORS of a public
+    bucket, the space's own CDN among them) refused that preflight. The file never loaded. Tremor's world outlines on
+    `cdn-dev.plitzi.com` are one example.
+  - **What changes:** a read now sends `Accept: application/json`, and `Content-Type` goes only with a body, unless the
+    author set their own. Headers the author adds still make the request non-simple, as they must.
+
+- Updated dependencies [4d10e0a]
+  - @plitzi/sdk-authoring@0.37.8
+  - @plitzi/sdk-elements@0.37.8
+  - @plitzi/sdk-interactions@0.37.8
+  - @plitzi/sdk-schema@0.37.8
+  - @plitzi/sdk-shared@0.37.8
+  - @plitzi/sdk-style@0.37.8
+  - @plitzi/plitzi-sdk@0.37.8
+  - @plitzi/sdk-server@0.37.8
+
 ## 0.37.7
 
 ### Patch Changes

package/README.md

@@ -73,6 +73,10 @@ The server is stateless: it resolves the space per request and reads and writes
 | `saveStyle(spaceId, env, style)` | for writes | Persist a mutated style document. |
 | `getChanges(spaceId, env, query)` | no | The space's change history, for the `plitzi://changes` resources. Writes arrive with an `SSRWriteContext` (`userId`, one `batch` per tool call) so a consumer can record them. |
 | `getOfflineData(spaceId, env, rev)` | for preview | Read side of draft-preview. Only the preview endpoint calls it. |
+| `getComponentCatalog(spaceId, env)` | no | The element types the space's plugins add, for the catalog resources. |
+| `getConnectors` / `saveConnector` / `deleteConnector` | for connectors | The space's connector manifests, read and written by the connector operations. |
+| `getActions` / `getActionTasks` / `saveAction` / `deleteAction` | for actions | The space's server actions, and the catalog of tasks a step may run — the deployment's and the space's own functions, each with its `origin`. |
+| `getFunctions` / `saveFunctions` / `tryFunction` | for functions | The space's functions: read for `plitzi://functions/{env}`, saved (built and checked, refused from an older copy) by `upsertFunctionFile` / `deleteFunctionFile`, and run by `plitzi_try_function`. |
 
 Schema and style are read as **separate documents** on purpose: `getOfflineData` is SSR-shaped and strips
 `style.platform`, which the style resources need.
@@ -92,6 +96,7 @@ resolves with `canWrite: false` reads everything and is refused at every write t
 | `plitzi_preview` | read | Render a draft to HTML through an SSR server |
 | `plitzi_screenshot` | read | Render a draft to a PNG (desktop, mobile or both) through the screenshot service |
 | `plitzi_render` | read | Render a self-contained UI widget, offline, with no space |
+| `plitzi_try_function` | write | Run one task of the space's functions against the draft, in the sandbox: its value, logs and error |
 
 Reads follow a filesystem model: list cheap, read one item in detail on demand. Agents are told never to
 hand-build a URI — every write and search response hands back the URI to use next.

package/dist/modules/mcp/helpers/components.d.ts

@@ -0,0 +1,14 @@
+import { Space } from './space';
+import { AIComponentSummary } from '../types';
+import { Schema, SpaceComponent } from '@plitzi/sdk-shared';
+/** A component by the name it is placed by, unless a page or a layout answers to it first. */
+export declare const findComponentByRef: (schema: Schema, ref: string) => SpaceComponent | undefined;
+/**
+ * The space as an op addressed to a component sees it: the component's tree as the only one, its root as the one root.
+ *
+ * `flat` IS the component's own object, so whatever the op writes lands in the component. Every other tree is out of
+ * sight — a component is closed, nothing in it may name them — but not out of mind: `document` is the whole space,
+ * which is what a new name has to be free of.
+ */
+export declare const componentView: (space: Space, component: SpaceComponent) => Space;
+export declare const componentSummariesToAI: (schema: Schema) => AIComponentSummary[];

package/dist/modules/mcp/helpers/components.js

@@ -0,0 +1,32 @@
+import { componentNamed, instancesOf } from "@plitzi/sdk-schema/helpers/components";
+//#region src/modules/mcp/helpers/components.ts
+/** A component by the name it is placed by, unless a page or a layout answers to it first. */
+var findComponentByRef = (schema, ref) => Object.hasOwn(schema.flat, ref) ? void 0 : componentNamed(schema, ref);
+/**
+* The space as an op addressed to a component sees it: the component's tree as the only one, its root as the one root.
+*
+* `flat` IS the component's own object, so whatever the op writes lands in the component. Every other tree is out of
+* sight — a component is closed, nothing in it may name them — but not out of mind: `document` is the whole space,
+* which is what a new name has to be free of.
+*/
+var componentView = (space, component) => ({
+	...space,
+	schema: {
+		...space.schema,
+		flat: component.flat,
+		pages: [component.rootId],
+		components: {}
+	},
+	document: space.document ?? space.schema
+});
+var componentSummariesToAI = (schema) => Object.values(schema.components).map((component) => ({
+	ref: component.id,
+	label: component.label ?? component.id,
+	props: component.props ?? {},
+	slots: component.slots ?? [],
+	rootRef: component.rootId,
+	instances: instancesOf(schema, component.id).length,
+	elementCount: Object.keys(component.flat).length
+}));
+//#endregion
+export { componentSummariesToAI, componentView, findComponentByRef };

package/dist/modules/mcp/helpers/guide.js

@@ -113,6 +113,8 @@ Never download a whole tree you do not need.
 - \`plitzi://schema/{env}/pages\` — page **summaries** (ref, label, elementCount, folder). No element trees.
 - \`plitzi://schema/{env}/layouts\` — the shared **layout shells** (header/sidebar/footer) and the pages rendered
   inside each. Read one like a page. See *Shared layouts* below.
+- \`plitzi://schema/{env}/components\` — the space's **components** (reusable subtrees): their props, slots, root and
+  how many places render each. Read one like a page. See *Components* below.
 - \`plitzi://folders/{env}\` — page **folders** (the sidebar tree): ref, name, slug, parentId. \`/{ref}\` for one.
 - \`plitzi://schema/{env}/pages/{ref}\` — one page as a **skeleton tree**: each node is \`ref/type/label\` **plus the
   style classes it attaches** (\`base\`, and \`slots\` for non-base slots) — names only, no CSS. So you can map every
@@ -645,7 +647,11 @@ any other (\`<namespace>.<action>\`), listed in \`plitzi://actions/{env}/tasks\`
   \`ctx.user\` (who asked, never their session). A secret is NAMED, never read: \`ctx.fetch(url, { credential: "stripe",
   headers: { authorization: "Bearer {{ credential.apiKey }}" } })\`.
 - **Stateless:** nothing a function keeps in memory outlives the call — a module-level cache or counter starts empty
-  every time, on whichever instance runs it. What must last goes in \`ctx.kv\`. A call gets 100 ms of CPU and 10 s.
+  every time, on whichever instance runs it. What must last goes in \`ctx.kv\`. A call gets 100 ms of CPU and 10 s;
+  a task that needs more says so — \`limits: { cpuMs: 1000, wallMs: 20000 }\`, or \`defineFunctions({ limits })\` for
+  all — up to the plan's ceiling. Asking above it is refused at save, never quietly cut.
+- **Routes** answer HTTP on the space's own host under \`/fn/\`: \`routes: { "GET /boards/:board": (request, ctx) =>
+  Response.json(…) }\` answers \`/fn/boards/kanban\` (\`ctx.params.board\`). No page may live under \`/fn\`.
 - **Saving builds and checks** the files: the batch is refused with each problem where it is (file and line). A
   namespace the platform uses (\`kv\`, \`http\`, \`flow\`…) is refused.
 - **Try it** with \`plitzi_try_function { task, params }\` before a page relies on it: the value, the logs, the error.
@@ -712,6 +718,47 @@ vocabulary:
 link, an upgrade prompt in the sidebar — it belongs in the LAYOUT, not in the page you happen to have open. Check
 the page's \`layout\` first; if the element you are looking for is not in the page's own tree, it is in the shell.
 
+## Components — a subtree written once, placed anywhere
+A **component** is a reusable subtree: a product card, a pricing tier, a testimonial — written once and placed on
+any page as an **instance**. It is part of the space, so it is published, versioned and copied with it. Its tree is
+not inside any page: it is a root of its own, like a layout, and **editing it changes every instance** — say so
+before you touch one.
+
+It is **closed**. Inside, a binding or a template reads **\`props\`** — what each instance hands in — and the globals
+(\`state\`, \`auth\`, \`navigation\`, \`theme\`, \`variables\`, \`computed\`), never the page an instance sits on. A
+component that needs a list row's record gets it as a prop: the INSTANCE binds it (\`item: "{{ list_rows.item }}"\`),
+the component reads \`{{ props.item.name }}\`.
+
+**Reading them.** \`plitzi://schema/{env}/components\` lists them: \`ref\`, \`label\`, \`props\`, \`slots\`, \`rootRef\`,
+\`instances\`. Read one like a page: \`plitzi://schema/{env}/pages/{componentRef}\` (and \`/styles\`).
+
+**Writing them.**
+- \`upsertComponent { ref, label?, props?, slots? }\` declares one — with nothing in it but its root, \`{ref}-root\`, a
+  container — or updates the declaration of one that exists (\`props\` is REPLACED whole). Fill it with every
+  element/binding/interaction op you already know, with **\`pageRef: "<componentRef>"\`**:
+  \`\`\`json
+  { "type": "upsertElement", "pageRef": "product-card", "parentRef": "product-card-root",
+    "element": { "ref": "product-card-title", "type": "heading" } }
+  \`\`\`
+- \`upsertComponent { ref, fromRef, instanceRef }\` makes a component OF an element that already exists: the element
+  and everything inside it become the component, and an instance named \`instanceRef\` takes its place, so the page
+  renders what it did. The way to turn a repeated block into one.
+- A **prop** is \`{ type, description, required?, default?, options? }\`, \`type\` one of \`text\`, \`textarea\`,
+  \`number\`, \`boolean\`, \`select\` (with \`options\`), \`scalar\`, \`json\`. Its name is read as \`{{ props.<name> }}\`, so
+  letters, digits and \`_\` — and never one an instance already has (\`referenceId\`, \`referenceType\`, \`slot\`…).
+- A **slot** is an element of the component's tree (usually an empty container) an instance fills with children.
+- \`deleteComponent { ref }\` removes one nothing places; while instances remain it is refused, naming them.
+
+**Placing one** is an element: a \`reference\` whose props say which component and hand in its props, one attribute each:
+\`\`\`json
+{ "type": "upsertElement", "pageRef": "shop", "parentRef": "grid",
+  "element": { "ref": "lamp-card", "type": "reference",
+    "props": { "referenceType": "component", "referenceId": "product-card", "title": "Lamp" },
+    "children": [ { "ref": "lamp-buy", "type": "button", "props": { "content": "Buy", "slot": "product-card-actions" } } ] } }
+\`\`\`
+A required prop left out, a prop the component does not declare, a value of the wrong kind or a child naming a slot
+the component does not have is reported by \`plitzi_validate\` — fix it before applying.
+
 ## Pages & folders
 - **Always set a \`slug\` when creating a page** (\`upsertPage\`) — it is the page's URL path and good practice for a
   clean, stable route (e.g. \`"pricing"\` or \`"posts/:postId"\`). Omit it and the page ref is used as the slug,

package/dist/modules/mcp/helpers/index.d.ts

@@ -1,4 +1,5 @@
 export * from './agentPrompt';
+export * from './components';
 export * from './computeVersion';
 export * from './space';
 export * from './uris';

package/dist/modules/mcp/helpers/space.d.ts

@@ -17,6 +17,11 @@ export interface Space {
      *  the deployment offers no functions: then there is nothing to read and every function op is refused. */
     functions?: FunctionsDraft;
     catalog?: ComponentCatalog;
+    /**
+     * The whole document, when `schema` is a view of one tree of it — a component's, which an op addressed to a
+     * component edits as if it were the space's only tree. What a new name has to be free of is still all of it.
+     */
+    document?: Schema;
 }
 export declare const cloneSpace: (space: Space) => Space;
 export declare const emptySpace: () => Space;

package/dist/modules/mcp/helpers/space.js

@@ -19,7 +19,8 @@ var emptySpace = () => ({
 		variables: [],
 		settings: { customCss: "" },
 		pages: [],
-		pageFolders: []
+		pageFolders: [],
+		components: {}
 	},
 	style: {
 		platform: {

package/dist/modules/mcp/helpers/uris.d.ts

@@ -9,6 +9,8 @@ export declare const pageUri: (env: Env, ref: string) => string;
 /** The shared layout shells. One of them is read as a page is — `pages/{ref}` resolves either root. */
 export declare const layoutsUri: (env: Env) => string;
 export declare const elementUri: (env: Env, ref: string) => string;
+/** The components. One of them is read as a page is — `pages/{ref}` resolves it — and edited with `pageRef: <ref>`. */
+export declare const componentsUri: (env: Env) => string;
 export declare const schemaVarsUri: (env: Env) => string;
 export declare const settingsUri: (env: Env) => string;
 export declare const interactionsUri: (env: Env) => string;

package/dist/modules/mcp/helpers/uris.js

@@ -9,6 +9,8 @@ var pageUri = (env, ref) => `plitzi://schema/${env}/pages/${ref}`;
 /** The shared layout shells. One of them is read as a page is — `pages/{ref}` resolves either root. */
 var layoutsUri = (env) => `plitzi://schema/${env}/layouts`;
 var elementUri = (env, ref) => `plitzi://schema/${env}/elements/${ref}`;
+/** The components. One of them is read as a page is — `pages/{ref}` resolves it — and edited with `pageRef: <ref>`. */
+var componentsUri = (env) => `plitzi://schema/${env}/components`;
 var schemaVarsUri = (env) => `plitzi://schema-variables/${env}`;
 var settingsUri = (env) => `plitzi://settings/${env}`;
 var interactionsUri = (env) => `plitzi://interactions/${env}`;
@@ -59,4 +61,4 @@ var itemTemplates = (env) => [
 *  family and extracts its ref in one step, without repeating the prefix string for both the startsWith and slice. */
 var afterPrefix = (uri, prefix) => uri.startsWith(prefix) ? uri.slice(prefix.length) : void 0;
 //#endregion
-export { actionTasksUri, actionUri, actionsUri, afterPrefix, aliasedRoots, changesUri, connectorPresetsUri, connectorUri, connectorsUri, cssPropertiesUri, dataSourcesUri, defUri, defsUri, elementUri, folderUri, foldersUri, fontUri, fontsUri, functionFileUri, functionsUri, globalUri, globalsUri, guideUri, idUri, idsUri, interactionsUri, itemTemplates, layoutsUri, pageUri, pagesUri, primerUri, schemaVarsUri, settingsUri, styleVarUri, styleVarsUri, typesUri };
+export { actionTasksUri, actionUri, actionsUri, afterPrefix, aliasedRoots, changesUri, componentsUri, connectorPresetsUri, connectorUri, connectorsUri, cssPropertiesUri, dataSourcesUri, defUri, defsUri, elementUri, folderUri, foldersUri, fontUri, fontsUri, functionFileUri, functionsUri, globalUri, globalsUri, guideUri, idUri, idsUri, interactionsUri, itemTemplates, layoutsUri, pageUri, pagesUri, primerUri, schemaVarsUri, settingsUri, styleVarUri, styleVarsUri, typesUri };

package/dist/modules/mcp/resources/primer.js

@@ -1,7 +1,8 @@
 import { buildDataSourceCatalog, buildInteractionCatalog } from "../catalogs/observed.js";
 import { buildTypeRegistry } from "../catalogs/registry.js";
 import { cssProperties, cssShorthands } from "../catalogs/index.js";
-import { connectorsUri, dataSourcesUri, defsUri, foldersUri, fontsUri, interactionsUri, layoutsUri, pagesUri, primerUri, schemaVarsUri, settingsUri, styleVarsUri, typesUri } from "../helpers/uris.js";
+import { componentSummariesToAI } from "../helpers/components.js";
+import { componentsUri, connectorsUri, dataSourcesUri, defsUri, foldersUri, fontsUri, interactionsUri, layoutsUri, pagesUri, primerUri, schemaVarsUri, settingsUri, styleVarsUri, typesUri } from "../helpers/uris.js";
 import { guideQuickstart } from "../helpers/guide.js";
 import { envelope } from "./envelope.js";
 import { connectorSummaries } from "./connectors.js";
@@ -83,6 +84,11 @@ var readPrimerResource = (space, env, uri) => {
 			value: layoutSummariesToAI(space.schema),
 			read: layoutsUri(env)
 		},
+		{
+			key: "components",
+			value: componentSummariesToAI(space.schema),
+			read: componentsUri(env)
+		},
 		{
 			key: "folders",
 			value: foldersToAI(space.schema),

package/dist/modules/mcp/resources/schema.js

@@ -1,14 +1,17 @@
 import { buildDataSourceCatalog, buildInteractionCatalog } from "../catalogs/observed.js";
+import { componentSummariesToAI, componentView, findComponentByRef } from "../helpers/components.js";
 import { findElementByRef, findRootByRef } from "../helpers/space.js";
-import { afterPrefix, dataSourcesUri, elementUri, folderUri, foldersUri, interactionsUri, layoutsUri, pageUri, pagesUri, schemaVarsUri, settingsUri } from "../helpers/uris.js";
+import { afterPrefix, componentsUri, dataSourcesUri, elementUri, folderUri, foldersUri, interactionsUri, layoutsUri, pageUri, pagesUri, schemaVarsUri, settingsUri } from "../helpers/uris.js";
 import { envelope } from "./envelope.js";
 import { elementView, folderRefToAI, foldersToAI, layoutSummariesToAI, pageSkeletonToAI, pageStylesToAI, pageSummariesToAI, schemaVariablesToAI, settingsToAI } from "../tools/operations/schema/translator.js";
+import { treeOf } from "@plitzi/sdk-schema/helpers/components";
 //#region src/modules/mcp/resources/schema.ts
 /** Element-schema reads: page listings/skeletons/styles, folders, single elements and schema variables. Returns
 *  undefined when the URI belongs to another domain, null when the shape is ours but the ref does not resolve. */
 var readSchemaResource = (space, env, uri) => {
 	if (uri === pagesUri(env)) return envelope(pageSummariesToAI(space.schema));
 	if (uri === layoutsUri(env)) return envelope(layoutSummariesToAI(space.schema));
+	if (uri === componentsUri(env)) return envelope(componentSummariesToAI(space.schema));
 	if (uri === foldersUri(env)) return envelope(foldersToAI(space.schema));
 	const folderRef = afterPrefix(uri, folderUri(env, ""));
 	if (folderRef !== void 0) {
@@ -17,19 +20,22 @@ var readSchemaResource = (space, env, uri) => {
 	}
 	const pageItem = afterPrefix(uri, pageUri(env, ""));
 	if (pageItem !== void 0) {
-		if (pageItem.endsWith("/styles")) {
-			const ref = pageItem.slice(0, -7);
-			const page = findRootByRef(space.schema, ref);
-			return page ? envelope(pageStylesToAI(space.schema, space.style, page)) : null;
-		}
-		const page = findRootByRef(space.schema, pageItem);
-		return page ? envelope(pageSkeletonToAI(space.schema, page, space.style)) : null;
+		const styles = pageItem.endsWith("/styles");
+		const ref = styles ? pageItem.slice(0, -7) : pageItem;
+		const component = findComponentByRef(space.schema, ref);
+		const target = component ? componentView(space, component) : space;
+		const page = findRootByRef(target.schema, component ? component.rootId : ref);
+		if (!page) return null;
+		return envelope(styles ? pageStylesToAI(target.schema, target.style, page) : pageSkeletonToAI(target.schema, page, target.style));
 	}
 	const elementRef = afterPrefix(uri, elementUri(env, ""));
 	if (elementRef !== void 0) {
-		const el = findElementByRef(space.schema, elementRef);
+		const componentId = treeOf(space.schema, elementRef)?.componentId;
+		const component = componentId ? findComponentByRef(space.schema, componentId) : void 0;
+		const target = component ? componentView(space, component) : space;
+		const el = findElementByRef(target.schema, elementRef);
 		if (!el) return null;
-		const view = elementView(space.schema, el, space.style);
+		const view = elementView(target.schema, el, target.style);
 		return {
 			stateVersion: view.version,
 			data: view.detail

package/dist/modules/mcp/server.js

@@ -69,7 +69,7 @@ var createMcpServer = async ({ adapters, getGrant, preview, screenshot, logger,
 	const getSpace = () => spacePromise ??= loadSpace();
 	const server = new McpServer({
 		name: "plitzi-mcp",
-		version: "0.37.7"
+		version: "0.37.9"
 	}, { instructions: hasSpace ? serverInstructions : widgetsOnlyInstructions });
 	const { getChanges } = adapters;
 	registerResources(server, getSpace, MCP_ENV, log, hasSpace, getChanges ? (query) => getChanges(requireSpaceId(), MCP_ENV, query) : void 0);

package/dist/modules/mcp/tests/components.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/mcp/tools/apply/dispatch.js

@@ -1,3 +1,5 @@
+import { componentView, findComponentByRef } from "../../helpers/components.js";
+import { pageUri } from "../../helpers/uris.js";
 import { fail } from "../../helpers/opResult.js";
 import { deleteAction } from "../operations/actions/deleteAction.js";
 import { patchAction } from "../operations/actions/patchAction.js";
@@ -9,6 +11,8 @@ import { deleteFunctionFile, upsertFunctionFile } from "../operations/functions/
 import { deleteBinding } from "../operations/schema/bindings/deleteBinding.js";
 import { patchBinding } from "../operations/schema/bindings/patchBinding.js";
 import { upsertBinding } from "../operations/schema/bindings/upsertBinding.js";
+import { deleteComponent } from "../operations/schema/components/deleteComponent.js";
+import { upsertComponent } from "../operations/schema/components/upsertComponent.js";
 import { deleteElement } from "../operations/schema/elements/deleteElement.js";
 import { moveElement } from "../operations/schema/elements/moveElement.js";
 import { patchElement } from "../operations/schema/elements/patchElement.js";
@@ -41,6 +45,25 @@ import { deleteStyleVariable } from "../operations/style/variables/deleteStyleVa
 import { upsertStyleVariable } from "../operations/style/variables/upsertStyleVariable.js";
 import { isStyleOp } from "../operations/index.js";
 //#region src/modules/mcp/tools/apply/dispatch.ts
+var isRooted = (op) => "pageRef" in op;
+/**
+* An element op names its root with `pageRef`, and a component is one: the op runs on the component's tree as if it
+* were the space's only one — rooted at the component's root — so every element op works inside a component with no
+* code of its own. What it made stale is the component, read as `pages/<component>`.
+*/
+var executeRooted = (space, env, op) => {
+	const component = isRooted(op) ? findComponentByRef(space.schema, op.pageRef) : void 0;
+	if (!component || !isRooted(op)) return executeOp(space, env, op);
+	const retargeted = {
+		...op,
+		pageRef: component.rootId
+	};
+	const result = executeOp(componentView(space, component), env, retargeted);
+	return {
+		...result,
+		staleResources: result.staleResources.map((uri) => uri === pageUri(env, component.rootId) ? pageUri(env, component.id) : uri)
+	};
+};
 var executeOp = (space, env, op) => {
 	switch (op.type) {
 		case "upsertElement": return upsertElement(space, env, op);
@@ -62,6 +85,8 @@ var executeOp = (space, env, op) => {
 		case "patchInteractionNode": return patchInteractionNode(space, env, op);
 		case "deleteInteraction": return deleteInteraction(space, env, op);
 		case "patchSettings": return patchSettings(space, env, op);
+		case "upsertComponent": return upsertComponent(space, env, op);
+		case "deleteComponent": return deleteComponent(space, env, op);
 		case "upsertDefinition": return upsertDefinition(space, env, op);
 		case "upsertDefinitions": return upsertDefinitions(space, env, op);
 		case "patchDefinition": return patchDefinition(space, env, op);
@@ -113,7 +138,7 @@ var applyOperations = (space, env, ops) => {
 	const droppedActions = /* @__PURE__ */ new Set();
 	for (let i = 0; i < ops.length; i++) {
 		const op = ops[i];
-		const result = executeOp(space, env, op);
+		const result = executeRooted(space, env, op);
 		if (result.errors) {
 			outcome.errors.push(...result.errors.map((e) => ({
 				...e,

package/dist/modules/mcp/tools/apply/index.d.ts

@@ -269,6 +269,17 @@ export declare const applyShape: {
             }>>;
             presence: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"upsertComponent">;
+        ref: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        slots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fromRef: z.ZodOptional<z.ZodString>;
+        instanceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"deleteComponent">;
+        ref: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;

package/dist/modules/mcp/tools/operations/index.d.ts

@@ -265,6 +265,17 @@ export declare const documentOperation: z.ZodDiscriminatedUnion<readonly [z.ZodO
         }>>;
         presence: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"upsertComponent">;
+    ref: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    slots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fromRef: z.ZodOptional<z.ZodString>;
+    instanceRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"deleteComponent">;
+    ref: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
@@ -1022,6 +1033,17 @@ export declare const operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>>;
         presence: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"upsertComponent">;
+    ref: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    slots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fromRef: z.ZodOptional<z.ZodString>;
+    instanceRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"deleteComponent">;
+    ref: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
@@ -2051,6 +2073,17 @@ export declare const operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject
         }>>;
         presence: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"upsertComponent">;
+    ref: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    slots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fromRef: z.ZodOptional<z.ZodString>;
+    instanceRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"deleteComponent">;
+    ref: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
@@ -3075,6 +3108,17 @@ export declare const documentOperations: z.ZodArray<z.ZodDiscriminatedUnion<read
         }>>;
         presence: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"upsertComponent">;
+    ref: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    slots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fromRef: z.ZodOptional<z.ZodString>;
+    instanceRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"deleteComponent">;
+    ref: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;

package/dist/modules/mcp/tools/operations/index.js

@@ -28,6 +28,8 @@ var documentOps = [
 	elementOps.patchInteractionNode,
 	elementOps.deleteInteraction,
 	elementOps.patchSettings,
+	elementOps.upsertComponent,
+	elementOps.deleteComponent,
 	styleOps.upsertDefinition,
 	styleOps.upsertDefinitions,
 	styleOps.patchDefinition,

package/dist/modules/mcp/tools/operations/schema/components/deleteComponent.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { OpResult, Space } from '../../../../helpers';
+import { Env } from '../../../../types';
+export declare const deleteComponentOp: z.ZodObject<{
+    type: z.ZodLiteral<"deleteComponent">;
+    ref: z.ZodString;
+}, z.core.$strip>;
+export type DeleteComponent = z.infer<typeof deleteComponentOp>;
+export declare const deleteComponent: (space: Space, env: Env, op: DeleteComponent) => OpResult;

package/dist/modules/mcp/tools/operations/schema/components/deleteComponent.js

@@ -0,0 +1,21 @@
+import { componentsUri } from "../../../../helpers/uris.js";
+import { empty, fail } from "../../../../helpers/opResult.js";
+import { componentNamed, instancesOf, removeComponent } from "@plitzi/sdk-schema/helpers/components";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/components/deleteComponent.ts
+var deleteComponentOp = z.object({
+	type: z.literal("deleteComponent"),
+	ref: z.string()
+}).describe("Remove a component nothing places any more.");
+var deleteComponent = (space, env, op) => {
+	if (!componentNamed(space.schema, op.ref)) return fail("ref", `Component "${op.ref}" not found`, `Read plitzi://schema/${env}/components for valid refs`);
+	const placed = instancesOf(space.schema, op.ref);
+	if (placed.length > 0 || !removeComponent(space.schema, op.ref)) return fail("ref", `Component "${op.ref}" is still placed by ${placed.map((instance) => `"${instance.id}"`).join(", ")}`, "detachInstance or deleteElement each of them first");
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [componentsUri(env)]
+	};
+};
+//#endregion
+export { deleteComponent, deleteComponentOp };

package/dist/modules/mcp/tools/operations/schema/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './deleteComponent';
+export * from './upsertComponent';

package/dist/modules/mcp/tools/operations/schema/components/upsertComponent.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { OpResult, Space } from '../../../../helpers';
+import { Env } from '../../../../types';
+export declare const upsertComponentOp: z.ZodObject<{
+    type: z.ZodLiteral<"upsertComponent">;
+    ref: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    slots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fromRef: z.ZodOptional<z.ZodString>;
+    instanceRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UpsertComponent = z.infer<typeof upsertComponentOp>;
+export declare const upsertComponent: (space: Space, env: Env, op: UpsertComponent) => OpResult;

package/dist/modules/mcp/tools/operations/schema/components/upsertComponent.js

@@ -0,0 +1,147 @@
+import { invalidateIndex } from "../../../../helpers/space.js";
+import { componentsUri, pageUri } from "../../../../helpers/uris.js";
+import { empty, fail } from "../../../../helpers/opResult.js";
+import { ID_REF_HINT, guardNewRef } from "../write.js";
+import { addComponent, componentNamed, propNameProblem, treeOf, updateComponent } from "@plitzi/sdk-schema/helpers/components";
+import { descendants } from "@plitzi/sdk-schema/helpers/elementTree";
+import { z } from "zod";
+import { isValidElementId } from "@plitzi/sdk-schema/helpers/elementId";
+//#region src/modules/mcp/tools/operations/schema/components/upsertComponent.ts
+/**
+* A prop as a component declares it. Checked when the op runs rather than spelled out in the op's schema: the op union
+* rides on every request of every conversation, and the guide — read once — says what a prop is.
+*/
+var componentProp = z.object({
+	type: z.enum([
+		"text",
+		"textarea",
+		"number",
+		"boolean",
+		"select",
+		"scalar",
+		"json"
+	]),
+	description: z.string(),
+	required: z.boolean().optional(),
+	default: z.union([
+		z.string(),
+		z.number(),
+		z.boolean()
+	]).optional(),
+	options: z.array(z.string()).optional(),
+	label: z.string().optional()
+});
+var upsertComponentOp = z.object({
+	type: z.literal("upsertComponent"),
+	ref: z.string(),
+	label: z.string().optional(),
+	props: z.record(z.string(), z.unknown()).optional().describe("{ name: { type, description, required?, default?, options? } }"),
+	slots: z.array(z.string()).optional(),
+	fromRef: z.string().optional().describe("New only: the element it is made of"),
+	instanceRef: z.string().optional().describe("With fromRef: the instance left in its place")
+}).describe("Declare or update a component; edit inside it with pageRef: \"<ref>\". See \"Components\" in plitzi://guide.");
+/** The declaration an op writes, with nothing it leaves out — an update keeps what it does not name. */
+var declarationOf = (op, props) => ({
+	...op.label === void 0 ? {} : { label: op.label },
+	...props === void 0 ? {} : { props },
+	...op.slots === void 0 ? {} : { slots: op.slots }
+});
+/** The props an op declares, each held to what a prop is — or why one is not, by name. */
+var parseProps = (props) => {
+	if (props === void 0) return {};
+	const parsed = {};
+	for (const [name, value] of Object.entries(props)) {
+		const result = componentProp.safeParse(value);
+		if (!result.success) return { error: `prop "${name}" is not a prop: ${result.error.issues.map((issue) => `${issue.path.join(".") || "it"} ${issue.message}`).join("; ")}` };
+		parsed[name] = result.data;
+	}
+	return { props: parsed };
+};
+/** Why a declaration cannot stand, in words, or undefined: the same two rules `sdk-schema` holds every writer to. */
+var declarationProblem = (declaration, flat) => {
+	for (const name of Object.keys(declaration.props ?? {})) {
+		const problem = propNameProblem(name);
+		if (problem) return problem;
+	}
+	const missing = (declaration.slots ?? []).find((slot) => !Object.hasOwn(flat, slot));
+	return missing ? `slot "${missing}" is not an element of the component` : void 0;
+};
+var upsertComponent = (space, env, op) => {
+	const { schema } = space;
+	const stale = [componentsUri(env), pageUri(env, op.ref)];
+	const props = parseProps(op.props);
+	if ("error" in props) return fail("props", props.error, "A prop is { type: \"text\" | \"textarea\" | \"number\" | \"boolean\" | \"select\" | \"scalar\" | \"json\", description, required?, default?, options? }");
+	const declaration = declarationOf(op, props.props);
+	const existing = componentNamed(schema, op.ref);
+	if (existing) {
+		if (op.fromRef) return fail("fromRef", `Component "${op.ref}" already exists`, "fromRef makes a NEW component; pick another ref");
+		const problem = declarationProblem({
+			...existing,
+			...declaration
+		}, existing.flat);
+		if (problem || !updateComponent(schema, op.ref, {
+			...existing,
+			...declaration
+		})) return fail("props", problem ?? `Component "${op.ref}" refused the declaration`, "Name props as {{ props.<name> }} reads them, and slots as elements of the tree");
+		return {
+			...empty(),
+			updated: 1,
+			staleResources: stale
+		};
+	}
+	if (!isValidElementId(op.ref)) return fail("ref", `"${op.ref}" is not a name a component can have`, ID_REF_HINT);
+	if (op.fromRef) {
+		const tree = treeOf(schema, op.fromRef);
+		const element = tree?.flat[op.fromRef];
+		if (!tree || !element?.definition.parentId) return fail("fromRef", `"${op.fromRef}" is not an element inside a page, a layout or a component`, "A page or a layout is a root, not a subtree — name an element inside one");
+		if (!op.instanceRef) return fail("instanceRef", "fromRef needs the name of the instance that takes the element’s place", "e.g. instanceRef: \"hero-card\"");
+		const guard = guardNewRef(space, op.instanceRef, "instanceRef");
+		if (guard) return guard;
+		const component = {
+			...declaration,
+			id: op.ref,
+			rootId: "",
+			flat: {}
+		};
+		const problem = declarationProblem(declaration, Object.fromEntries([op.fromRef, ...descendants(tree.flat, op.fromRef)].map((id) => [id, tree.flat[id]])));
+		if (problem || !addComponent(schema, component, {
+			elementId: op.fromRef,
+			instanceId: op.instanceRef
+		})) return fail("props", problem ?? `"${op.fromRef}" could not be made a component`, "Slots name elements inside fromRef");
+		invalidateIndex(schema);
+		return {
+			...empty(),
+			created: 1,
+			staleResources: stale,
+			elementRefs: [op.instanceRef]
+		};
+	}
+	const rootRef = `${op.ref}-root`;
+	const guard = guardNewRef(space, rootRef, "ref");
+	if (guard) return guard;
+	const component = {
+		...declaration,
+		id: op.ref,
+		rootId: rootRef,
+		flat: { [rootRef]: {
+			id: rootRef,
+			attributes: { subType: "div" },
+			definition: {
+				label: op.label ?? op.ref,
+				type: "container",
+				rootId: rootRef,
+				items: [],
+				styleSelectors: { base: "" }
+			}
+		} }
+	};
+	const problem = declarationProblem(declaration, component.flat);
+	if (problem || !addComponent(schema, component)) return fail("props", problem ?? `Component "${op.ref}" could not be declared`, "A new component has one element yet — its root; add the rest with upsertElement { pageRef: \"<ref>\" } first, then name slots");
+	return {
+		...empty(),
+		created: 1,
+		staleResources: stale
+	};
+};
+//#endregion
+export { upsertComponent, upsertComponentOp };

package/dist/modules/mcp/tools/operations/schema/index.d.ts

@@ -21,3 +21,4 @@ export * from './interactions/upsertInteractionFlow';
 export * from './interactions/patchInteractionNode';
 export * from './interactions/deleteInteraction';
 export * from './settings/patchSettings';
+export * from './components';

package/dist/modules/mcp/tools/operations/schema/operations.d.ts

@@ -283,4 +283,17 @@ export declare const elementOps: {
             presence: import('zod').ZodOptional<import('zod').ZodBoolean>;
         }, import('zod/v4/core').$strip>>>>;
     }, import('zod/v4/core').$strip>;
+    upsertComponent: import('zod').ZodObject<{
+        type: import('zod').ZodLiteral<"upsertComponent">;
+        ref: import('zod').ZodString;
+        label: import('zod').ZodOptional<import('zod').ZodString>;
+        props: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodUnknown>>;
+        slots: import('zod').ZodOptional<import('zod').ZodArray<import('zod').ZodString>>;
+        fromRef: import('zod').ZodOptional<import('zod').ZodString>;
+        instanceRef: import('zod').ZodOptional<import('zod').ZodString>;
+    }, import('zod/v4/core').$strip>;
+    deleteComponent: import('zod').ZodObject<{
+        type: import('zod').ZodLiteral<"deleteComponent">;
+        ref: import('zod').ZodString;
+    }, import('zod/v4/core').$strip>;
 };

package/dist/modules/mcp/tools/operations/schema/operations.js

@@ -1,6 +1,8 @@
 import { deleteBindingOp } from "./bindings/deleteBinding.js";
 import { patchBindingOp } from "./bindings/patchBinding.js";
 import { upsertBindingOp } from "./bindings/upsertBinding.js";
+import { deleteComponentOp } from "./components/deleteComponent.js";
+import { upsertComponentOp } from "./components/upsertComponent.js";
 import { deleteElementOp } from "./elements/deleteElement.js";
 import { moveElementOp } from "./elements/moveElement.js";
 import { patchElementOp } from "./elements/patchElement.js";
@@ -39,7 +41,9 @@ var elementOps = {
 	upsertInteractionFlow: upsertInteractionFlowOp,
 	patchInteractionNode: patchInteractionNodeOp,
 	deleteInteraction: deleteInteractionOp,
-	patchSettings: patchSettingsOp
+	patchSettings: patchSettingsOp,
+	upsertComponent: upsertComponentOp,
+	deleteComponent: deleteComponentOp
 };
 //#endregion
 export { elementOps };

package/dist/modules/mcp/tools/operations/schema/write.js

@@ -1,6 +1,7 @@
 import { findRootByRef, indexAddElement, resolveRef } from "../../../helpers/space.js";
 import { folderUri, foldersUri, layoutsUri, pageUri, pagesUri, schemaVarsUri, settingsUri } from "../../../helpers/uris.js";
 import { fail } from "../../../helpers/opResult.js";
+import { documentIds } from "@plitzi/sdk-schema/helpers/components";
 import { elementIdConflict, isValidElementId } from "@plitzi/sdk-schema/helpers/elementId";
 import FlatMap from "@plitzi/sdk-schema/helpers/FlatMap";
 //#region src/modules/mcp/tools/operations/schema/write.ts
@@ -12,7 +13,8 @@ var collectInputRefs = (input) => [input.ref, ...(input.children ?? []).flatMap(
 *  it. Both rules are sdk-schema's `elementIdConflict` — never restated here, so the MCP cannot drift from what
 *  the builder and the schema validator enforce. Null when the name is usable. */
 var guardNewRef = (space, ref, field) => {
-	const conflict = elementIdConflict(space.schema.flat, ref);
+	const elsewhere = documentIds(space.document ?? space.schema).has(ref) ? `"${ref}" is already used by another element here` : null;
+	const conflict = elementIdConflict(space.schema.flat, ref) ?? elsewhere;
 	if (!conflict) return null;
 	return isValidElementId(ref) ? fail(field, conflict, TAKEN_HINT) : fail(field, conflict, ID_REF_HINT);
 };

package/dist/modules/mcp/tools/preview.d.ts

@@ -265,6 +265,17 @@ export declare const previewShape: {
             }>>;
             presence: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"upsertComponent">;
+        ref: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        slots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fromRef: z.ZodOptional<z.ZodString>;
+        instanceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"deleteComponent">;
+        ref: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;

package/dist/modules/mcp/tools/render.d.ts

@@ -267,6 +267,17 @@ export declare const renderShape: {
             }>>;
             presence: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"upsertComponent">;
+        ref: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        slots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fromRef: z.ZodOptional<z.ZodString>;
+        instanceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"deleteComponent">;
+        ref: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;

package/dist/modules/mcp/tools/screenshot.d.ts

@@ -265,6 +265,17 @@ export declare const screenshotShape: {
             }>>;
             presence: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"upsertComponent">;
+        ref: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        slots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fromRef: z.ZodOptional<z.ZodString>;
+        instanceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"deleteComponent">;
+        ref: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;

package/dist/modules/mcp/tools/shared/validator/batch.js

@@ -8,7 +8,7 @@ var batchDeclaredVars = (ops) => {
 };
 var batchDeclaredPages = (ops) => {
 	const refs = /* @__PURE__ */ new Set();
-	for (const op of ops) if (op.type === "upsertPage" || op.type === "upsertLayout") refs.add(op.ref);
+	for (const op of ops) if (op.type === "upsertPage" || op.type === "upsertLayout" || op.type === "upsertComponent") refs.add(op.ref);
 	return refs;
 };
 var batchDeclaredFolders = (ops) => {

package/dist/modules/mcp/tools/shared/validator/index.js

@@ -1,6 +1,7 @@
 import { observedDataSources, observedInteractionActions } from "../../../catalogs/observed.js";
 import { buildTypeRegistry } from "../../../catalogs/registry.js";
 import { elementTypeNames } from "../../../catalogs/index.js";
+import { componentView, findComponentByRef } from "../../../helpers/components.js";
 import { findElementByRef, findFolderByRef, findPageByRef, findRootByRef, folderAncestorIds, getLayoutElements, getPageElements, pageFoldersOf, resolveRef, routeParamNames } from "../../../helpers/space.js";
 import { MAX_OPS } from "../../operations/index.js";
 import { batchDeclaredElements, batchDeclaredFolders, batchDeclaredPages, batchDeclaredVariants, batchDeclaredVars } from "./batch.js";
@@ -11,6 +12,7 @@ import { checkSlotCss } from "./css.js";
 import { checkRef } from "./refs.js";
 import { checkElementInput, checkRawMarkup, checkTypeProps, checkVariantApplication } from "./elements.js";
 import { checkInteractionNode } from "./interactions.js";
+import { treeOf } from "@plitzi/sdk-schema/helpers/components";
 import { isValidElementId } from "@plitzi/sdk-schema/helpers/elementId";
 //#region src/modules/mcp/tools/shared/validator/index.ts
 var STYLE_CATEGORIES = [
@@ -50,8 +52,8 @@ var buildValidationCtx = (space, ops, mode = "space") => {
 		knownTypes: /* @__PURE__ */ new Set([...Object.keys(registry.types), ...elementTypeNames]),
 		typeProps: new Map(Object.entries(registry.types).map(([type, info]) => [type, new Set(Object.keys(info.props))])),
 		typeMeta: buildTypeMeta(space.catalog),
-		elementType: (ref) => (findElementByRef(space.schema, ref) ?? findPageByRef(space.schema, ref))?.definition.type,
-		elementExists: (ref) => batchElements.has(ref) || Boolean(findElementByRef(space.schema, ref) ?? findPageByRef(space.schema, ref)),
+		elementType: (ref) => treeOf(space.schema, ref)?.flat[ref]?.definition.type,
+		elementExists: (ref) => batchElements.has(ref) || treeOf(space.schema, ref) !== void 0,
 		schemaVars: /* @__PURE__ */ new Set([
 			...space.schema.variables.map((v) => v.name),
 			...routeParamNames(space.schema),
@@ -81,13 +83,19 @@ var validateOperations = (space, ops, mode = "space") => {
 	});
 	ops.forEach((op, i) => {
 		const base = `operations[${i}]`;
+		const component = "pageRef" in op ? findComponentByRef(space.schema, op.pageRef) : void 0;
+		const scoped = component ? componentView(space, component).schema : space.schema;
 		if ((op.type === "upsertElement" || op.type === "patchElement" || op.type === "deleteElement" || op.type === "moveElement" || op.type === "upsertBinding" || op.type === "patchBinding" || op.type === "deleteBinding" || op.type === "upsertInteractionFlow" || op.type === "patchInteractionNode" || op.type === "deleteInteraction") && op.pageRef) {
-			if (!findRootByRef(space.schema, op.pageRef) && !batchPages.has(op.pageRef)) {
-				const validRefs = [...getPageElements(space.schema).map((page) => page.id), ...getLayoutElements(space.schema).map((layout) => layout.id)];
+			if (!component && !findRootByRef(space.schema, op.pageRef) && !batchPages.has(op.pageRef)) {
+				const validRefs = [
+					...getPageElements(space.schema).map((page) => page.id),
+					...getLayoutElements(space.schema).map((layout) => layout.id),
+					...Object.keys(space.schema.components)
+				];
 				ctx.errors.push({
 					path: `${base}.pageRef`,
-					message: `Page or layout "${op.pageRef}" does not exist`,
-					hint: "Use an existing page or layout ref, or create the page with upsertPage earlier in the same batch",
+					message: `Page, layout or component "${op.pageRef}" does not exist`,
+					hint: "Use an existing page, layout or component ref, or create it earlier in the same batch",
 					validValues: validRefs
 				});
 			}
@@ -100,8 +108,8 @@ var validateOperations = (space, ops, mode = "space") => {
 				break;
 			case "patchElement": {
 				checkRef(op.ref, `${base}.ref`, ctx);
-				const page = findRootByRef(space.schema, op.pageRef);
-				const target = page ? resolveRef(space.schema, page, op.ref) : void 0;
+				const page = findRootByRef(scoped, component ? component.rootId : op.pageRef);
+				const target = page ? resolveRef(scoped, page, op.ref) : void 0;
 				if (op.props && target && target.id !== page?.id) {
 					checkRawMarkup(target.definition.type, op.props, base, ctx);
 					checkTypeProps(target.definition.type, op.props, base, ctx);
@@ -230,7 +238,7 @@ var validateOperations = (space, ops, mode = "space") => {
 				break;
 			case "patchInteractionNode": {
 				checkRef(op.ref, `${base}.ref`, ctx);
-				const existing = findElementByRef(space.schema, op.ref)?.definition.interactions?.[op.nodeId];
+				const existing = findElementByRef(scoped, op.ref)?.definition.interactions?.[op.nodeId];
 				if (existing) {
 					const merged = {
 						id: existing.id,

package/dist/modules/mcp/tools/validate.d.ts

@@ -266,6 +266,17 @@ export declare const validateShape: {
             }>>;
             presence: import('zod').ZodOptional<import('zod').ZodBoolean>;
         }, import('zod/v4/core').$strip>>>>;
+    }, import('zod/v4/core').$strip>, import('zod').ZodObject<{
+        type: import('zod').ZodLiteral<"upsertComponent">;
+        ref: import('zod').ZodString;
+        label: import('zod').ZodOptional<import('zod').ZodString>;
+        props: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodUnknown>>;
+        slots: import('zod').ZodOptional<import('zod').ZodArray<import('zod').ZodString>>;
+        fromRef: import('zod').ZodOptional<import('zod').ZodString>;
+        instanceRef: import('zod').ZodOptional<import('zod').ZodString>;
+    }, import('zod/v4/core').$strip>, import('zod').ZodObject<{
+        type: import('zod').ZodLiteral<"deleteComponent">;
+        ref: import('zod').ZodString;
     }, import('zod/v4/core').$strip>, import('zod').ZodObject<{
         desktop: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodUnion<readonly [import('zod').ZodString, import('zod').ZodNumber]>>>;
         tablet: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodUnion<readonly [import('zod').ZodString, import('zod').ZodNumber]>>>;

package/dist/modules/mcp/types/aiSchema.d.ts

@@ -49,6 +49,26 @@ export interface AILayoutSummary {
     slots: string[];
     elementCount: number;
 }
+/** A component of the space: a reusable subtree, placed on a page as an instance and edited as a root of its own. */
+export interface AIComponentSummary {
+    ref: string;
+    label: string;
+    /** What an instance hands in, each an attribute of the instance and read inside as `{{ props.<name> }}`. */
+    props: Record<string, {
+        type: string;
+        description: string;
+        required?: boolean;
+        default?: unknown;
+        options?: string[];
+    }>;
+    /** Elements of its tree an instance fills with its children, each child naming the one it fills (`slot`). */
+    slots: string[];
+    /** The root of its tree: `pageRef` for every element op inside it is the component's ref. */
+    rootRef: string;
+    /** How many places render it. */
+    instances: number;
+    elementCount: number;
+}
 /** A page folder in the sidebar tree. `ref` is the folder's id; pages reference it
  *  by that id via their `folder`, and nested folders via `parentId`. */
 export interface AIFolder {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-mcp",
-  "version": "0.37.7",
+  "version": "0.37.9",
   "license": "AGPL-3.0",
   "files": [
     "dist",
@@ -30,14 +30,14 @@
   "dependencies": {
     "@modelcontextprotocol/ext-apps": "^1.7.5",
     "@modelcontextprotocol/sdk": "^1.30.1",
-    "@plitzi/plitzi-sdk": "0.37.7",
-    "@plitzi/sdk-authoring": "0.37.7",
-    "@plitzi/sdk-elements": "0.37.7",
-    "@plitzi/sdk-interactions": "0.37.7",
-    "@plitzi/sdk-schema": "0.37.7",
-    "@plitzi/sdk-server": "0.37.7",
-    "@plitzi/sdk-shared": "0.37.7",
-    "@plitzi/sdk-style": "0.37.7",
+    "@plitzi/plitzi-sdk": "0.37.9",
+    "@plitzi/sdk-authoring": "0.37.9",
+    "@plitzi/sdk-elements": "0.37.9",
+    "@plitzi/sdk-interactions": "0.37.9",
+    "@plitzi/sdk-schema": "0.37.9",
+    "@plitzi/sdk-server": "0.37.9",
+    "@plitzi/sdk-shared": "0.37.9",
+    "@plitzi/sdk-style": "0.37.9",
     "ejs": "^6.0.1",
     "esbuild": "^0.28.2",
     "zod": "^4.6.5"