@plitzi/sdk-server 0.32.4 → 0.32.5

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 };

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

@@ -1,75 +0,0 @@
-//#region src/modules/mcp/resources/glossary/resource.ts
-var resourceResource = {
-	uri: "plitzi://docs/resource",
-	name: "Plitzi Docs: Resource",
-	description: "A CDN-stored file in a Plitzi space — images, videos, documents, plugins, and templates uploaded to cloud storage.",
-	mimeType: "text/markdown",
-	content: `# Resource
-
-A **Resource** is a file stored on a CDN (AWS S3 or Cloudflare R2) and associated with a Plitzi space. Resources include images, videos, documents, application files, plugin bundles, and page templates.
-
-## TypeScript Shape
-
-\`\`\`typescript
-type ResourceType = 'image' | 'video' | 'document' | 'application' | 'plugin' | 'template';
-
-type Resource = {
-  id: string;              // Storage key (S3/R2 object path)
-  cdnIdentifier: string;   // Which CDN configuration to use
-  name: string;            // Display filename
-  path: string;            // Full public CDN URL
-  type: ResourceType;
-  size: number;            // File size in bytes
-  metadata?: PluginManifest;  // Present when type === 'plugin' or 'template'
-};
-
-type Cdn = {
-  identifier: string;
-  name: string;
-  domain: string;
-  provider: 's3' | 'r2';
-  region: string;
-  endpoint?: string;       // Custom endpoint for R2 / S3-compatible storage
-  bucketName: string;
-  prefix: string;
-  credential?: SpaceCredential;
-  createdAt: number;
-  updatedAt: number;
-};
-\`\`\`
-
-## Resource Types
-
-| Type | Description |
-|---|---|
-| \`image\` | PNG, JPEG, GIF, WebP, SVG |
-| \`video\` | MP4, WebM, OGG |
-| \`document\` | PDF, Word, Excel, etc. |
-| \`application\` | Generic binary files |
-| \`plugin\` | Plugin JS bundles — \`metadata\` contains \`PluginManifest\` |
-| \`template\` | Page template presets — \`metadata\` contains \`PluginManifest\` |
-
-## Key Properties
-
-- **\`id\`** — the storage object path (e.g. \`images/hero.jpg\`). Used together with \`cdnIdentifier\` to address the file.
-- **\`cdnIdentifier\`** — references a configured CDN (the space can have multiple CDNs).
-- **\`path\`** — the full public URL to use in \`<img src>\`, CSS \`url()\`, etc.
-- **\`metadata\`** — only present for \`plugin\` and \`template\` types; contains the \`PluginManifest\`.
-
-## Relationships
-
-- Resources are managed at the **Space** level and shared across all environments.
-- **Plugin** resources (type \`plugin\`) power the component library.
-- Elements reference image/video resources via \`attributes\` (e.g. \`element.attributes.src\`).
-
-## Common Operations
-
-- \`get_resources\` — list all resources, optionally filtered by type or CDN.
-- \`get_resource\` — fetch a single resource by \`id\` and \`cdnIdentifier\`.
-- \`add_resource\` — upload a file from a URL to the CDN.
-- \`move_resource\` — relocate a resource to a different CDN prefix/folder.
-- \`remove_resource\` — delete a resource from the CDN.
-`
-};
-//#endregion
-export { resourceResource };

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

@@ -1,69 +0,0 @@
-//#region src/modules/mcp/resources/glossary/schema.ts
-var schemaResource = {
-	uri: "plitzi://docs/schema",
-	name: "Plitzi Docs: Schema",
-	description: "Core data structure of a Plitzi space — holds all pages, elements, variables, and settings.",
-	mimeType: "text/markdown",
-	content: `# Schema
-
-The \`Schema\` is the primary data structure of a Plitzi space. It is a serializable, flat representation of the entire page tree plus global configuration.
-
-## TypeScript Shape
-
-\`\`\`typescript
-type Schema = {
-  flat: Record<string, Element>;           // All elements keyed by their ID
-  definition: {
-    name: string;                          // Human-readable space name
-    permanentUrl: string;                  // URL slug (e.g. "my-app")
-  };
-  variables: SchemaVariable[];             // Space-level dynamic variables
-  settings: {
-    keepState?: boolean;
-    stateStorage?: 'localStorage' | 'sessionStorage';
-    customCss: string;
-    userProvider?: 'auth0' | 'basic' | 'custom' | '';
-    auth0Domain?: string;
-    auth0ClientId?: string;
-    tokenStorage?: 'localStorage' | 'sessionStorage' | '';
-    loginUrl?: string;
-    userUrl?: string;
-    refreshUrl?: string;
-    logoutUrl?: string;
-    detailsPath?: string;
-    tokenPath?: string;
-    expirationTimePath?: string;
-  };
-  rsc?: {
-    enabled?: boolean;
-    transport?: 'json' | 'stream';
-    path?: string;                         // Defaults to '/_rsc'
-  };
-  pages: string[];                         // Ordered list of root page element IDs
-  pageFolders: PageFolder[];               // Hierarchical page organization
-};
-\`\`\`
-
-## Key Properties
-
-- **\`flat\`** — the entire element tree as a dictionary. Every element (page, container, component) lives here. Children are referenced by IDs stored in \`definition.items\`.
-- **\`pages\`** — ordered list of element IDs for the top-level pages. The elements themselves are in \`flat\`.
-- **\`pageFolders\`** — hierarchical folder structure for organizing pages in the builder sidebar.
-- **\`variables\`** — schema-level variables that can be injected into elements via bindings.
-- **\`settings\`** — authentication provider configuration (Auth0, basic, custom token), state persistence, and custom global CSS.
-- **\`rsc\`** — optional React Server Components configuration.
-
-## Relationships
-
-- Contains **Element** objects in \`flat\`.
-- Contains **SchemaVariable** entries in \`variables\`.
-- Paired with a **Style** object that holds all CSS for the same space/environment.
-- Each **Segment** also has its own \`schema\` with the same structure but scoped to the segment.
-
-## Environments
-
-Each environment (\`main\`, \`development\`, \`staging\`, \`production\`) can have an independent schema snapshot. The \`main\` environment is the live working copy.
-`
-};
-//#endregion
-export { schemaResource };

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

@@ -1,60 +0,0 @@
-//#region src/modules/mcp/resources/glossary/schemaVariable.ts
-var schemaVariableResource = {
-	uri: "plitzi://docs/schema-variable",
-	name: "Plitzi Docs: Schema Variable",
-	description: "A space-level dynamic variable in Plitzi — typed values that can be injected into elements via bindings.",
-	mimeType: "text/markdown",
-	content: `# Schema Variable
-
-A **Schema Variable** is a space-level dynamic variable defined in \`schema.variables\`. Variables can be injected into element \`attributes\` or \`style\` via bindings, making them a lightweight way to parameterize behavior and appearance without hardcoding values.
-
-## TypeScript Shape
-
-\`\`\`typescript
-type SchemaVariable = {
-  name: string;       // Unique identifier used in bindings (e.g. 'primaryColor')
-  category: string;   // Grouping label shown in the builder UI
-  type:
-    | 'text'
-    | 'number'
-    | 'email'
-    | 'password'
-    | 'select'
-    | 'select2'
-    | 'checkbox'
-    | 'textarea'
-    | 'color'
-    | 'switch';
-  value: string;                                  // Default/current value
-  subValues: { when: RuleGroup; value: string }[]; // Conditional overrides
-};
-\`\`\`
-
-## Key Properties
-
-- **\`name\`** — the variable identifier used when binding to elements. Must be unique within the schema.
-- **\`category\`** — organizes variables into logical groups in the builder panel (e.g. \`'Colors'\`, \`'Typography'\`).
-- **\`type\`** — determines the editor widget and value format. \`color\` stores a hex/rgba string; \`switch\` stores \`'true'\`/\`'false'\`.
-- **\`value\`** — the base value. All values are stored as strings regardless of type.
-- **\`subValues\`** — conditional overrides: when a \`RuleGroup\` condition is met, the variable uses that value instead of the default. Enables rule-based theming and personalization.
-
-## Difference from Style Variables
-
-| | Schema Variable | Style Variable |
-|---|---|---|
-| Stored in | \`schema.variables\` | \`style.variables\` |
-| Used for | Element attributes, logic | CSS design tokens |
-| Types | text, color, switch, etc. | string, number, theme-aware |
-| Scope | Element bindings | CSS properties |
-
-## Common Operations
-
-- \`create_schema_variable\` — define a new variable.
-- \`update_schema_variable\` — change the value, category, or conditional rules.
-- \`delete_schema_variable\` — remove a variable (breaks any bindings referencing it).
-
-Segment variables use: \`create_segment_variable\`, \`update_segment_variable\`, \`delete_segment_variable\`.
-`
-};
-//#endregion
-export { schemaVariableResource };

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

@@ -1,59 +0,0 @@
-//#region src/modules/mcp/resources/glossary/segment.ts
-var segmentResource = {
-	uri: "plitzi://docs/segment",
-	name: "Plitzi Docs: Segment",
-	description: "A reusable UI template in Plitzi — a named, versioned component group with its own schema and style.",
-	mimeType: "text/markdown",
-	content: `# Segment
-
-A **Segment** is a reusable UI template. It encapsulates a sub-tree of elements with its own isolated schema and style. Segments can be embedded inside pages and reused across the space. Think of them as design-system components built visually.
-
-## TypeScript Shape
-
-\`\`\`typescript
-type Segment = {
-  id: string;
-  identifier: string;           // Unique string key (e.g. 'hero-banner')
-  definition: {
-    name: string;               // Human-readable display name
-    description: string;
-    baseElementId: string;      // Root element ID within segment.schema.flat
-  };
-  environment: Environment;     // 'main' | 'development' | 'staging' | 'production'
-  schema: Schema;               // The segment's own element tree
-  style: Style;                 // The segment's own CSS definitions
-};
-\`\`\`
-
-## Key Properties
-
-- **\`identifier\`** — the stable string ID used to reference this segment when embedding it in pages.
-- **\`definition.baseElementId\`** — the ID of the root element inside \`segment.schema.flat\`. This is the entry point when the segment is rendered.
-- **\`schema\`** — a full \`Schema\` object scoped to the segment. Contains the element sub-tree in \`flat\`.
-- **\`style\`** — a full \`Style\` object scoped to the segment. CSS is isolated from the space style.
-- **\`environment\`** — each environment has an independent version of the segment.
-
-## Isolation
-
-Segment schema and style are completely isolated from the space schema/style. This means:
-- Style selectors in a segment do not conflict with space-level selectors.
-- Variables inside a segment are scoped to the segment.
-- When a segment is updated and published, all pages using it pick up the new version.
-
-## Relationships
-
-- A **Segment** contains a **Schema** and a **Style** just like a space.
-- Elements inside the segment follow the same **Element** structure.
-- Segments reference **Environment** for versioning.
-
-## Common Operations
-
-- \`create_segment\` — create a new segment definition.
-- \`update_segment\` — rename or update description.
-- \`delete_segment\` — remove a segment.
-- \`create_segment_element\` / \`update_segment_element\` / \`delete_segment_element\` — manage elements inside.
-- \`create_segment_variable\` / \`update_segment_variable\` / \`delete_segment_variable\` — manage schema variables inside.
-`
-};
-//#endregion
-export { segmentResource };

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

@@ -1,73 +0,0 @@
-//#region src/modules/mcp/resources/glossary/space.ts
-var spaceResource = {
-	uri: "plitzi://docs/space",
-	name: "Plitzi Docs: Space",
-	description: "A Plitzi project workspace — the top-level container for schema, style, plugins, segments, collections, and deployments.",
-	mimeType: "text/markdown",
-	content: `# Space
-
-A **Space** is the top-level container of a Plitzi project. It holds everything: the page structure (schema), styling (style), plugins, segments, collections, CDN resources, and deployment configurations.
-
-## TypeScript Shape (partial)
-
-\`\`\`typescript
-type Space = {
-  id: number;
-  name: string;
-  permanentUrl: string;           // URL slug identifying the space
-  verified: boolean;              // Whether the custom domain is verified
-};
-
-type SpaceDeployment = {
-  id: number;
-  environment: Environment;       // 'production' | 'staging' | 'development' | 'main'
-  revision: number | null;
-  domain: string;
-  isVerified: boolean;
-  default: boolean;
-  credential: SpaceCredential | null;  // Cloud storage credential for deployment
-  createdAt: number;
-  updatedAt: number;
-};
-
-type SpaceCredential = {
-  identifier: string;
-  name: string;
-  provider: 's3' | 'r2' | 'ssr';
-  inUse: boolean;
-  usedIn: { usedFrom: string; name: string }[];
-  createdAt: number;
-  updatedAt: number;
-};
-\`\`\`
-
-## Key Concepts
-
-- **\`permanentUrl\`** — a stable URL slug (e.g. \`my-app\`) that identifies the space. Also stored in \`schema.definition.permanentUrl\`.
-- **Environments** — each space has up to 4 environments: \`main\` (working copy), \`development\`, \`staging\`, \`production\`. Each has its own schema, style, and deployment.
-- **\`SpaceDeployment\`** — maps an environment to a public domain and cloud storage credential for publishing.
-- **\`SpaceCredential\`** — AWS S3 or Cloudflare R2 credentials used to store published assets.
-
-## Relationships
-
-- A space has one **Schema** and one **Style** per environment.
-- A space owns all **Segments**, **Collections**, and **Resources** (CDN files).
-- A space has installed **Plugins**.
-- The \`main\` environment is always the live editing copy; publishing copies it to \`production\` (or another target environment).
-
-## Settings
-
-Space-level settings live in \`schema.settings\` and control:
-- Authentication provider (Auth0, basic JWT, custom token endpoint)
-- State persistence (localStorage vs. sessionStorage)
-- Custom global CSS
-
-## Common Operations
-
-- \`list_spaces\` — list all accessible spaces.
-- \`publish_space\` — publish \`main\` environment to a target environment.
-- \`update_space_settings\` — modify \`schema.settings\` fields.
-`
-};
-//#endregion
-export { spaceResource };

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

@@ -1,81 +0,0 @@
-//#region src/modules/mcp/resources/glossary/style.ts
-var styleResource = {
-	uri: "plitzi://docs/style",
-	name: "Plitzi Docs: Style",
-	description: "The styling system of a Plitzi space — CSS definitions organized by display mode, selector, and theme.",
-	mimeType: "text/markdown",
-	content: `# Style
-
-The \`Style\` object holds all CSS definitions for a Plitzi space. It is paired one-to-one with a \`Schema\` per environment. Styles are organized by display mode (responsive breakpoints), CSS selector, and optionally by theme (light/dark).
-
-## TypeScript Shape
-
-\`\`\`typescript
-type Style = {
-  platform: Record<DisplayMode, Record<string, StyleItem>>;
-  mode?: 'mobile-first' | 'desktop-first';
-  theme: {
-    default: StyleThemeMode;      // 'system' | 'light' | 'dark'
-    schemes: StyleThemeMode[];    // Enabled theme schemes
-  };
-  variables: Partial<StyleVariables>;
-};
-
-type DisplayMode = 'desktop' | 'tablet' | 'mobile';
-type StyleThemeMode = 'system' | 'light' | 'dark';
-
-type StyleItem = {
-  name: string;                    // The CSS selector string
-  type: 'class' | 'element' | 'id';
-  variables?: Partial<StyleVariables>;
-  attributes: StyleAttributes;     // CSS properties per sub-selector
-  cache: string;                   // Pre-compiled CSS string (read-only)
-  componentType?: string;          // Plugin type that owns this selector
-};
-
-type StyleAttributes = Record<string, StyleBlock>;  // key = sub-selector name (e.g. 'base', 'header')
-
-type StyleBlock = {
-  default?: StyleObject;                        // Base CSS properties
-  states?: Partial<Record<StyleState, StyleObject>>;   // Pseudo-classes
-  variants?: Record<string, Omit<StyleBlock, 'variants'>>;  // Custom variants
-};
-
-type StyleState = 'hover' | 'active' | 'focus' | 'disabled' | 'checked' | 'visited';
-type StyleObject = Partial<Record<StyleCategory, StyleValue>>;
-type StyleValue = number | string;
-
-// StyleVariableValue can be theme-aware
-type StyleVariableValue = string | number | {
-  light?: string;
-  dark?: string;
-  default?: string;
-};
-\`\`\`
-
-## Key Properties
-
-- **\`platform\`** — top-level split by \`DisplayMode\`. Each mode holds a dictionary of selector → \`StyleItem\`. Desktop is the base; tablet and mobile override via breakpoints.
-- **\`StyleItem.name\`** — the raw CSS selector (e.g. \`.btn-primary\`, \`#hero\`, \`button\`).
-- **\`StyleItem.type\`** — whether the selector is a class, element tag, or ID.
-- **\`StyleItem.attributes\`** — the CSS data, keyed by sub-selector slot names. The \`base\` slot always corresponds to the element itself. Other slots (e.g. \`header\`, \`icon\`) target internal parts of a component.
-- **\`StyleBlock.default\`** — normal-state CSS properties.
-- **\`StyleBlock.states\`** — CSS overrides for pseudo-classes (hover, focus, disabled, etc.).
-- **\`StyleBlock.variants\`** — named visual variants applied via \`element.definition.initialState.styleVariant\`.
-- **\`StyleItem.cache\`** — compiled CSS string. Recomputed automatically; do not modify directly.
-- **\`variables\`** — design tokens (colors, spacing, shadows, custom) at the style or item level.
-
-## Relationships
-
-- Each \`Element\` references its style entries via \`definition.styleSelectors\`, mapping slot names to selector strings in \`style.platform[mode]\`.
-- **Style variables** (\`StyleVariable\`) are design tokens shared across the style system.
-- A **Segment** has its own isolated \`Style\` object, separate from the space style.
-
-## Display Mode Behavior
-
-- Styles are applied from most-specific breakpoint down to \`desktop\`.
-- In \`mobile-first\` mode, \`desktop\` styles are the widest override; in \`desktop-first\` (default), \`mobile\` overrides narrow screens.
-`
-};
-//#endregion
-export { styleResource };