@plitzi/sdk-server 0.32.4 → 0.32.6

package/dist/modules/mcp/helpers.js

@@ -1,75 +0,0 @@
-import { z } from "zod";
-//#region src/modules/mcp/helpers.ts
-var zodToJsonSchema = (schema) => {
-	if (schema instanceof z.ZodObject) {
-		const properties = {};
-		const required = [];
-		for (const [key, value] of Object.entries(schema.shape)) {
-			properties[key] = zodToJsonSchema(value);
-			if (value instanceof z.ZodString || value instanceof z.ZodNumber || value instanceof z.ZodBoolean) {
-				if (!value.isOptional()) required.push(key);
-			}
-		}
-		return {
-			type: "object",
-			properties,
-			required: required.length > 0 ? required : []
-		};
-	}
-	if (schema instanceof z.ZodString) return { type: "string" };
-	if (schema instanceof z.ZodNumber) return { type: "number" };
-	if (schema instanceof z.ZodBoolean) return { type: "boolean" };
-	if (schema instanceof z.ZodEnum) return {
-		type: "string",
-		enum: schema.options
-	};
-	if (schema instanceof z.ZodOptional) return zodToJsonSchema(schema._def.innerType);
-	if (schema instanceof z.ZodUnion) return { oneOf: schema.options.map((opt) => zodToJsonSchema(opt)) };
-	if (schema instanceof z.ZodArray) return {
-		type: "array",
-		items: zodToJsonSchema(schema.element)
-	};
-	if (schema instanceof z.ZodRecord) return {
-		type: "object",
-		additionalProperties: zodToJsonSchema(schema.valueType)
-	};
-	return {};
-};
-var getAllowedModes = (operationType) => {
-	return operationType === "write" ? ["build"] : ["plan", "build"];
-};
-var toolResponseOk = (data, agentMessage) => {
-	return {
-		content: [{
-			type: "text",
-			text: agentMessage ?? JSON.stringify(data ?? null, null, 2)
-		}],
-		data
-	};
-};
-var toolResponseErr = (error) => ({
-	content: [{
-		type: "text",
-		text: error instanceof Error ? error.message : error
-	}],
-	isError: true
-});
-var isToolActive = (tool, adapters) => Boolean(tool.handler || tool.adapterName && adapters[tool.adapterName]);
-var resolveToolHandler = (tool, adapters) => {
-	if (tool.handler) return tool.handler;
-	if (tool.adapterName) return adapterWrapper(tool.adapterName, adapters[tool.adapterName]);
-};
-var bindTools = (tools, adapters) => tools.filter((tool) => isToolActive(tool, adapters)).map((tool) => ({
-	...tool,
-	handler: resolveToolHandler(tool, adapters)
-}));
-var adapterWrapper = (adapterName, handler) => {
-	return async (args, ctx) => {
-		if (!handler) return toolResponseErr(`Adapter ${adapterName} not found`);
-		const result = await handler(args, ctx);
-		if ("error" in result) return toolResponseErr(result.error);
-		return toolResponseOk(result.data);
-	};
-};
-//#endregion
-export { adapterWrapper, bindTools, getAllowedModes, isToolActive, resolveToolHandler, toolResponseErr, toolResponseOk, zodToJsonSchema };

package/dist/modules/mcp/resources/glossary/binding.js

@@ -1,73 +0,0 @@
-//#region src/modules/mcp/resources/glossary/binding.ts
-var bindingResource = {
-	uri: "plitzi://docs/binding",
-	name: "Plitzi Docs: Binding",
-	description: "Data bindings in Plitzi — connections that dynamically drive element attributes, style, or state from data sources.",
-	mimeType: "text/markdown",
-	content: `# Binding
-
-A **Binding** connects a data source to an element property. At runtime, the bound value replaces the element's static attribute, style, or initial state. Bindings enable dynamic content — data from collections, variables, navigation params, or other elements can drive what is displayed or how it looks.
-
-## TypeScript Shape
-
-\`\`\`typescript
-type BindingCategory = 'attributes' | 'style' | 'initialState';
-
-type ElementBinding = {
-  id: string;
-  source: string;                   // Data source ID / reference
-  fromPath?: string;                // Path within the source data (e.g. 'user.name')
-  transformers?: BindingTransformer[];  // Optional value transforms
-  when?: RuleGroup;                 // Conditional activation rule
-  enabled?: boolean;
-  toPath: string;                   // Target attribute/style/state path to overwrite
-};
-
-type BindingTransformer = {
-  type: 'utility' | 'unknown';
-  action: string;                   // Transform function name
-  params: { valueType: string; value: string };
-};
-\`\`\`
-
-## Binding Categories
-
-Bindings are grouped by what they target inside an element:
-
-| Category | What it overwrites |
-|---|---|
-| \`attributes\` | Fields in \`element.attributes\` (e.g. \`text\`, \`src\`, \`href\`) |
-| \`style\` | Style-related data (e.g. active style variant) |
-| \`initialState\` | Initial runtime state values |
-
-## Key Properties
-
-- **\`source\`** — identifies the data source (a collection ID, a schema variable name, a navigation param key, etc.).
-- **\`fromPath\`** — dot-notation path into the source data to extract the bound value (e.g. \`'record.title'\`).
-- **\`toPath\`** — dot-notation path of the target property to set on the element (e.g. \`'text'\`, \`'src'\`).
-- **\`transformers\`** — optional chain of value transforms applied before writing to \`toPath\`.
-- **\`when\`** — a \`RuleGroup\` condition; the binding only applies when the condition evaluates to true.
-
-## Where Bindings Are Stored
-
-Bindings live inside \`element.definition.bindings\`:
-
-\`\`\`typescript
-element.definition.bindings = {
-  attributes: [
-    { id: '...', source: 'collection-posts', fromPath: 'title', toPath: 'text', ... }
-  ],
-  style: [...],
-  initialState: [...]
-}
-\`\`\`
-
-## Relationships
-
-- Bindings reference **Schema Variables** (source by variable name) or external data sources.
-- Bindings are part of **Element** definitions.
-- **Interactions** complement bindings by handling user-triggered events (click, change).
-`
-};
-//#endregion
-export { bindingResource };

package/dist/modules/mcp/resources/glossary/collection.js

@@ -1,76 +0,0 @@
-//#region src/modules/mcp/resources/glossary/collection.ts
-var collectionResource = {
-	uri: "plitzi://docs/collection",
-	name: "Plitzi Docs: Collection",
-	description: "A CMS-style data store in Plitzi — a typed set of records with configurable fields.",
-	mimeType: "text/markdown",
-	content: `# Collection
-
-A **Collection** is a CMS-style data store inside a Plitzi space. It has a defined field schema and holds typed records. Collections are used to manage dynamic content (blog posts, product listings, team members, etc.) that elements can bind to via data sources.
-
-## TypeScript Shape
-
-\`\`\`typescript
-type Collection = {
-  id: string;
-  name: string;              // Singular name (e.g. 'Post')
-  namePlural: string;        // Plural name (e.g. 'Posts')
-  description: string;
-  privacy: 'public' | 'private';
-  fields: Record<string, CollectionField>;   // Field schema keyed by field ID
-  records: CollectionRecord[];
-};
-
-type CollectionField = {
-  id: string;
-  name: string;              // Human-readable label
-  machineName: string;       // Programmatic key used in record values
-  type:
-    | 'text' | 'richText' | 'image' | 'multiImage'
-    | 'video' | 'link' | 'email' | 'phone'
-    | 'number' | 'date' | 'switch' | 'color'
-    | 'option' | 'file';
-  params: {
-    primary: boolean;        // Whether this is the display/title field
-    required: boolean;
-  };
-};
-
-type CollectionRecord = {
-  id: string;
-  values: Record<string, string | number | boolean>;  // Keyed by field machineName
-  status: 'draft' | 'published' | 'archived';
-  createdAt: number;
-  updatedAt: number;
-  publishedAt?: number;
-};
-\`\`\`
-
-## Key Properties
-
-- **\`fields\`** — the schema of the collection. Each field has a \`machineName\` which is the key used in \`record.values\`.
-- **\`CollectionField.type\`** — determines the data type and editor widget. Use \`richText\` for HTML content, \`image\` for single image uploads.
-- **\`CollectionField.params.primary\`** — marks the main display field (title/name). Used in lists and pickers.
-- **\`CollectionRecord.values\`** — the actual record data, keyed by \`field.machineName\`.
-- **\`CollectionRecord.status\`** — content lifecycle. Only \`published\` records are visible in production.
-
-## Relationships
-
-- Elements can bind to collection data via **Bindings** (data source type \`collection\`).
-- Collections belong to a **Space** and are available across all environments.
-
-## Common Operations
-
-- \`get_collections\` — list all collections in the space.
-- \`get_collection\` — get a collection with its field schema.
-- \`create_collection\` — define a new content type.
-- \`update_collection\` — rename or modify a collection.
-- \`delete_collection\` — remove collection and all records.
-- \`get_collection_records\` — fetch records (optionally filtered by status).
-- \`create_collection_record\` — add a new record.
-- \`update_collection_record\` — edit an existing record.
-- \`delete_collection_record\` — remove a record.
-`
-};
-//#endregion
-export { collectionResource };

package/dist/modules/mcp/resources/glossary/displayMode.js

@@ -1,50 +0,0 @@
-//#region src/modules/mcp/resources/glossary/displayMode.ts
-var displayModeResource = {
-	uri: "plitzi://docs/display-mode",
-	name: "Plitzi Docs: Display Mode",
-	description: "Responsive breakpoints in Plitzi — desktop, tablet, and mobile style layers.",
-	mimeType: "text/markdown",
-	content: `# Display Mode
-
-A **Display Mode** represents a responsive breakpoint in the Plitzi style system. Styles are defined per display mode, allowing different visual rules at each screen size.
-
-## Type
-
-\`\`\`typescript
-type DisplayMode = 'desktop' | 'tablet' | 'mobile';
-\`\`\`
-
-## Structure in Style
-
-The \`Style.platform\` object holds one style layer per display mode:
-
-\`\`\`typescript
-style.platform = {
-  desktop: Record<string, StyleItem>,   // Base styles (widest breakpoint)
-  tablet: Record<string, StyleItem>,    // Overrides for tablet-width screens
-  mobile: Record<string, StyleItem>     // Overrides for mobile-width screens
-};
-\`\`\`
-
-Each mode contains the same set of CSS selectors (keyed by selector string). A selector defined only in \`desktop\` inherits its rules at all sizes unless overridden in \`tablet\` or \`mobile\`.
-
-## Cascade Direction
-
-- **Desktop-first** (default, \`style.mode === 'desktop-first'\`): \`desktop\` is the base. \`tablet\` overrides at medium widths. \`mobile\` overrides at narrow widths.
-- **Mobile-first** (\`style.mode === 'mobile-first'\`): \`mobile\` is the base. \`tablet\` and \`desktop\` add styles as the viewport widens.
-
-## In MCP Operations
-
-MCP style tools that modify selectors accept a \`displayMode\` parameter:
-
-\`\`\`typescript
-createStyleSelector({ displayMode: 'mobile', selector: '.hero', ... })
-updateStyleSelector({ displayMode: 'tablet', selector: '.hero', ... })
-deleteStyleSelector({ displayMode: 'desktop', selector: '.hero' })
-\`\`\`
-
-Omitting \`displayMode\` typically defaults to \`desktop\`.
-`
-};
-//#endregion
-export { displayModeResource };

package/dist/modules/mcp/resources/glossary/element.js

@@ -1,68 +0,0 @@
-//#region src/modules/mcp/resources/glossary/element.ts
-var elementResource = {
-	uri: "plitzi://docs/element",
-	name: "Plitzi Docs: Element",
-	description: "A single UI component instance in a Plitzi page — the building block of every schema.",
-	mimeType: "text/markdown",
-	content: `# Element
-
-An \`Element\` is a single instance of a UI component in a Plitzi page. Every visual item — pages, containers, text blocks, forms, images — is an element. The entire page tree is stored as a flat dictionary of elements keyed by ID.
-
-## TypeScript Shape
-
-\`\`\`typescript
-type Element<TAttributes = Record<string, unknown>> = {
-  id: string;
-  attributes: TAttributes & { subType?: string };  // Component-specific configuration
-  definition: ElementDefinition;
-};
-
-type ElementDefinition = {
-  rootId: string;            // ID of the page/root element this belongs to
-  label: string;             // Human-readable name shown in the builder
-  type: string;              // Element type identifier (e.g. 'container', 'text', 'image')
-  parentId?: string;         // ID of the parent element (undefined = root)
-  items?: string[];          // Ordered array of child element IDs
-  styleSelectors: {
-    base: string;            // Always present — the primary CSS class
-    [key: string]: string;   // Additional sub-selectors (e.g. 'header', 'body', 'icon')
-  };
-  bindings?: Partial<Record<'attributes' | 'style' | 'initialState', ElementBinding[]>>;
-  interactions?: Record<string, ElementInteraction>;
-  initialState?: {
-    styleVariant?: Record<string, Record<string, string | string[]>>;
-    styleSelectors?: ElementDefinition['styleSelectors'];
-    visibility?: boolean;
-    [key: string]: unknown;
-  };
-  runtime?: 'server' | 'client' | 'shared';    // RSC render target
-  loadStrategy?: 'eager' | 'lazy' | 'visible'; // When to load/render
-};
-\`\`\`
-
-## Key Properties
-
-- **\`id\`** — unique identifier, used as the key in \`schema.flat\`.
-- **\`attributes\`** — component-specific data (text content, URLs, settings). Shape varies by plugin type. \`subType\` selects a variant within the same plugin.
-- **\`definition.type\`** — element type identifier that determines which component renders this element. Get valid values from \`get_builder_context\` (\`elementDefaults\` keys) or from the \`type\` field of existing elements in \`get_schema\`. This is NOT the plugin name from \`list_plugins\`.
-- **\`definition.parentId\`** — parent element ID. Elements without \`parentId\` are root elements (pages).
-- **\`definition.items\`** — ordered child IDs. Walk the tree by following \`items\` recursively.
-- **\`definition.styleSelectors\`** — maps named selector slots to actual CSS class strings from the \`Style\`. \`base\` is always present.
-- **\`definition.bindings\`** — data bindings that dynamically overwrite \`attributes\`, \`style\`, or \`initialState\` fields at runtime.
-- **\`definition.interactions\`** — event handlers (onClick, onChange, etc.) mapping to configured actions.
-- **\`definition.rootId\`** — always points to the page element this element belongs to.
-
-## Relationships
-
-- All elements live in \`schema.flat[id]\`.
-- Parent–child links: \`definition.parentId\` (up) and \`definition.items\` (down).
-- Style data for each element is found in \`style.platform[displayMode][styleSelector]\`.
-- **Segment** elements have their own \`schema.flat\` but follow the same structure.
-
-## Page Elements
-
-A page is an element whose type corresponds to a page plugin. Its ID appears in \`schema.pages\`. Pages are the top-level roots; they have no \`parentId\` and their \`rootId\` points to themselves.
-`
-};
-//#endregion
-export { elementResource };

package/dist/modules/mcp/resources/glossary/environment.js

@@ -1,48 +0,0 @@
-//#region src/modules/mcp/resources/glossary/environment.ts
-var environmentResource = {
-	uri: "plitzi://docs/environment",
-	name: "Plitzi Docs: Environment",
-	description: "Deployment environments in Plitzi — main (working copy), development, staging, and production.",
-	mimeType: "text/markdown",
-	content: `# Environment
-
-An **Environment** in Plitzi is a named version of a space's schema, style, and segments. Each environment can be published independently to its own domain.
-
-## Type
-
-\`\`\`typescript
-type Environment = 'production' | 'staging' | 'development' | 'main';
-\`\`\`
-
-## Environments
-
-| Environment | Purpose |
-|---|---|
-| \`main\` | The live editing/working copy. Always present. All builder changes apply here. |
-| \`development\` | Internal preview environment. Used for QA before staging. |
-| \`staging\` | Pre-production review. Shown to stakeholders before going live. |
-| \`production\` | The public-facing live site. Published from \`main\` when changes are ready. |
-
-## Key Behaviors
-
-- **All builder operations target \`main\`** unless explicitly scoped to another environment.
-- Publishing copies the \`main\` schema/style to the target environment (e.g. \`production\`).
-- Each environment can have a different domain and CDN deployment.
-- Segments are also versioned per environment.
-
-## In API and Tools
-
-Most MCP tools accept an \`environment\` parameter (defaults to \`main\`) that scopes the read/write operation:
-
-\`\`\`typescript
-// Example: get schema for the staging environment
-getSchema({ environment: 'staging' })
-\`\`\`
-
-## AI Context
-
-The \`AiContext.environment\` field tells the AI agent which environment the current session is operating in. This affects which schema/style data is read and which changes are applied.
-`
-};
-//#endregion
-export { environmentResource };

package/dist/modules/mcp/resources/glossary/interaction.js

@@ -1,62 +0,0 @@
-//#region src/modules/mcp/resources/glossary/interaction.ts
-var interactionResource = {
-	uri: "plitzi://docs/interaction",
-	name: "Plitzi Docs: Interaction",
-	description: "Event-driven action handlers in Plitzi — connect user events (click, change, submit) to platform actions.",
-	mimeType: "text/markdown",
-	content: `# Interaction
-
-An **Interaction** is an event handler attached to an element. When a user triggers an event (click, change, form submit, etc.), the interaction executes a configured action — navigation, state mutation, data operation, animation, etc.
-
-## TypeScript Shape
-
-\`\`\`typescript
-type ElementInteraction = {
-  id: string;
-  title: string;                        // Human-readable name
-  type: InteractionCallbackType;        // Event type (e.g. 'onClick', 'onChange')
-  action: string;                       // Action identifier (e.g. 'navigate', 'setVariable')
-  params: InteractionCallbackParamValues;  // Action-specific parameters
-  preview: Record<string, unknown>;     // Preview data for the builder
-  elementId: string;                    // Element this interaction belongs to
-  beforeNode: string;                   // Flow order: ID of preceding step
-  afterNode: string;                    // Flow order: ID of following step
-  flowId: string;                       // Groups interactions in the same flow
-  enabled: boolean;
-  when?: RuleGroup;                     // Conditional: only fire when rule matches
-};
-\`\`\`
-
-## Key Properties
-
-- **\`type\`** — the DOM or lifecycle event to listen on (e.g. \`onClick\`, \`onChange\`, \`onSubmit\`, \`onLoad\`).
-- **\`action\`** — the platform action to execute. Common actions: \`navigate\`, \`setSchemaVariable\`, \`toggleVisibility\`, \`submitForm\`, \`openModal\`.
-- **\`params\`** — action-specific configuration object. Shape depends on \`action\`.
-- **\`flowId\` + \`beforeNode\` / \`afterNode\`** — interactions can be chained into a sequential flow. Multiple interactions sharing a \`flowId\` form an ordered chain.
-- **\`when\`** — a \`RuleGroup\` condition; the interaction only fires when the condition is true.
-
-## Where Interactions Are Stored
-
-Interactions are stored in \`element.definition.interactions\` as a record keyed by interaction ID:
-
-\`\`\`typescript
-element.definition.interactions = {
-  'inter-abc': {
-    id: 'inter-abc',
-    type: 'onClick',
-    action: 'navigate',
-    params: { url: '/dashboard' },
-    ...
-  }
-}
-\`\`\`
-
-## Relationships
-
-- Interactions belong to **Elements**.
-- **Bindings** handle passive data-driven updates; interactions handle active user-triggered events.
-- Interactions can mutate **Schema Variables** (via \`setSchemaVariable\` action), which then propagate through bindings.
-`
-};
-//#endregion
-export { interactionResource };

package/dist/modules/mcp/resources/glossary/page.js

@@ -1,70 +0,0 @@
-//#region src/modules/mcp/resources/glossary/page.ts
-var pageResource = {
-	uri: "plitzi://docs/page",
-	name: "Plitzi Docs: Page",
-	description: "A top-level page in a Plitzi space — a root element whose ID appears in schema.pages.",
-	mimeType: "text/markdown",
-	content: `# Page
-
-A **Page** in Plitzi is a root-level element. It is stored in \`schema.flat\` like any other element, but its ID is listed in \`schema.pages\` to identify it as a navigable page. Pages are the containers that hold all other elements.
-
-## Structure
-
-Pages are regular \`Element\` objects:
-
-\`\`\`typescript
-// A page element in schema.flat
-{
-  id: 'page-abc123',
-  attributes: { title: 'Home', slug: '/' },  // Page-specific attributes
-  definition: {
-    rootId: 'page-abc123',    // Points to itself — pages are their own root
-    label: 'Home',
-    type: 'page',             // Type matches the page plugin identifier
-    items: ['section-1', 'section-2'],  // Top-level child elements
-    styleSelectors: { base: '.page-home' }
-    // No parentId — pages have no parent
-  }
-}
-
-// Referenced in schema.pages
-schema.pages = ['page-abc123', 'page-def456', ...]
-\`\`\`
-
-## Key Properties
-
-- **\`schema.pages\`** — ordered array of page element IDs. The order controls navigation/sidebar ordering.
-- **\`definition.rootId === id\`** — a page's \`rootId\` always points to itself.
-- **\`definition.parentId\`** — absent (undefined) for pages; they are top-level.
-- **\`attributes.slug\`** — the URL path segment for this page (e.g. \`/about\`).
-
-## Page Folders
-
-Pages can be organized into **page folders** (\`schema.pageFolders\`):
-
-\`\`\`typescript
-type PageFolder = {
-  id: string;
-  name: string;
-  slug: string;
-  parentId?: string;  // Nested folders supported
-};
-\`\`\`
-
-Folders only affect visual organization in the builder sidebar — they do not affect routing.
-
-## Relationships
-
-- Pages are a special-case of **Element** — same structure, just listed in \`schema.pages\`.
-- All child elements are regular elements in \`schema.flat\`, linked via \`definition.parentId\` / \`definition.items\`.
-
-## Common Operations
-
-- \`create_page\` — add a new page element.
-- \`update_page\` — rename or modify a page.
-- \`delete_page\` — remove a page and all its children.
-- \`create_page_folder\` / \`update_page_folder\` / \`delete_page_folder\` — manage page folder hierarchy.
-`
-};
-//#endregion
-export { pageResource };

package/dist/modules/mcp/resources/glossary/plugin.js

@@ -1,96 +0,0 @@
-//#region src/modules/mcp/resources/glossary/plugin.ts
-var pluginResource = {
-	uri: "plitzi://docs/plugin",
-	name: "Plitzi Docs: Plugin",
-	description: "An external UI component definition in Plitzi — a packaged React component with manifest, assets, and builder constraints.",
-	mimeType: "text/markdown",
-	content: `# Plugin
-
-A **Plugin** is a packaged UI component definition loaded into a Plitzi space. Plugins provide the React component code that renders elements.
-
-**Important distinction:** A *plugin* is what you install in a space. An *element type identifier* is what you pass as \`type\` when creating elements. The two are related (each plugin exposes one or more element types), but they are accessed differently:
-- \`list_plugins\` returns installed plugins with their name, version, and description — it does NOT return element type identifiers.
-- Element type identifiers are the keys of \`elementDefaults\` in \`get_builder_context\`, or the \`type\` field on existing elements from \`get_schema\`.
-
-## TypeScript Shape
-
-\`\`\`typescript
-type Plugin = {
-  type: string;              // Plugin type ID — matches element.definition.type
-  scope: string;             // Module federation scope name
-  module: string;            // Module federation module name
-  resource: string;          // CDN URL of the plugin bundle
-  manifest: PluginManifest;
-  assets: Asset[];
-  assetsSettings: Asset[];
-  attributes: ComponentDefinition['attributes'];   // Attribute schema
-  defaultStyle: ComponentDefinition['defaultStyle'];
-  builder: PluginBuilder;    // Visual editor constraints
-  settings: Record<string, unknown>;
-  subPlugins?: string[];     // Other plugin types this can contain
-  isMain?: boolean;
-};
-
-type PluginManifest = {
-  version: string;
-  author: string;
-  icon?: string;
-  definition: {
-    name: string;
-    backgroundColor: string;
-    category: string;
-    icon: string;
-    license: string;
-    owner: string;
-    verified: boolean;
-    website: string;
-  };
-  pluginSchema: Record<string, PluginSchema>;  // Schema per subType
-  assets: Record<string, ManifestAsset>;
-  assetsSettings: Record<string, ManifestAsset>;
-  root: string;
-  runtime: { module: string; scope: string };
-  created: string;
-  updated: string;
-};
-
-type PluginBuilder = {
-  canDelete?: boolean;
-  canDragDrop?: boolean;
-  canSelect?: boolean;
-  canMove?: boolean;
-  canTemplate?: boolean;
-  itemsAllowed?: string[];      // Which plugin types can be children
-  itemsNotAllowed?: string[];
-};
-\`\`\`
-
-## Key Properties
-
-- **\`type\`** — internal identifier that links this plugin to elements. When an element has \`definition.type === plugin.type\`, that plugin renders it. You do not reference this directly — use \`elementDefaults\` keys from \`get_builder_context\` to get valid element type values.
-- **\`manifest.pluginSchema\`** — per-subType attribute schema. Controls what fields appear in the builder panel for each element variant (\`attributes.subType\`).
-- **\`builder\`** — constraints for the visual editor. \`itemsAllowed\` restricts which plugin types can be dropped as children.
-- **\`subPlugins\`** — additional plugin types bundled with this one (loaded together).
-- **\`scope\` / \`module\` / \`resource\`** — Module Federation coordinates used to load the component at runtime.
-
-## Relationship to Elements
-
-When a page renders, each element is matched to its plugin by \`definition.type\`. The plugin provides:
-1. The React component for rendering.
-2. The builder UI for editing \`attributes\`.
-3. The default style selectors and style structure.
-
-## Resource Type
-
-Plugins can also be stored as CDN **Resources** with \`type: 'plugin'\`. In that case, the resource includes a \`metadata\` field containing the \`PluginManifest\`.
-
-## Common Operations
-
-- \`list_plugins\` — list all plugins installed in the space.
-- \`add_plugin\` — install a plugin from the resource library.
-- \`update_plugin\` — update plugin settings or version.
-- \`remove_plugin\` — uninstall a plugin.
-`
-};
-//#endregion
-export { pluginResource };