@plitzi/sdk-server 0.32.4 → 0.32.6

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

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

@@ -1,77 +0,0 @@
-//#region src/modules/mcp/resources/glossary/styleSelector.ts
-var styleSelectorResource = {
-	uri: "plitzi://docs/style-selector",
-	name: "Plitzi Docs: Style Selector",
-	description: "A CSS selector entry in the Plitzi style system — holds all visual rules for one selector across states and variants.",
-	mimeType: "text/markdown",
-	content: `# Style Selector (StyleItem)
-
-A **style selector** is a single entry in \`style.platform[displayMode]\`. It represents one CSS selector (class, element, or ID) and stores all its CSS rules organized by sub-selector, state, and variant.
-
-## TypeScript Shape
-
-\`\`\`typescript
-type StyleItem = {
-  name: string;                        // The CSS selector (e.g. '.hero-section')
-  type: 'class' | 'element' | 'id';
-  variables?: Partial<StyleVariables>; // Design tokens scoped to this selector
-  attributes: Record<string, StyleBlock>;  // CSS per sub-selector slot
-  cache: string;                       // Pre-compiled CSS (auto-managed)
-  componentType?: string;              // Plugin type that created this selector
-};
-
-type StyleBlock = {
-  default?: StyleObject;                            // Normal state CSS
-  states?: Partial<Record<StyleState, StyleObject>>;// Pseudo-class overrides
-  variants?: Record<string, Omit<StyleBlock, 'variants'>>;  // Named variants
-};
-
-type StyleState = 'hover' | 'active' | 'focus' | 'disabled' | 'checked' | 'visited';
-type StyleObject = Partial<Record<StyleCategory, string | number>>;
-\`\`\`
-
-## Sub-selector Slots
-
-The \`attributes\` object is keyed by **slot names**, not raw CSS selectors. Each slot maps to a structural part of the component:
-
-- \`base\` — always present; targets the root DOM element of the component.
-- Other slots (e.g. \`header\`, \`body\`, \`icon\`, \`label\`) target internal parts defined by the plugin.
-
-The mapping from slot name → CSS selector is managed by the plugin renderer.
-
-## Variants
-
-Variants allow a single selector to have multiple named visual appearances (e.g. \`primary\`, \`danger\`, \`sm\`, \`lg\`). An element activates a variant through \`definition.initialState.styleVariant\`:
-
-\`\`\`typescript
-// element.definition.initialState.styleVariant
-{
-  base: { base: 'primary' }        // Apply 'primary' variant on the 'base' slot
-}
-\`\`\`
-
-## Relationship to Elements
-
-Elements reference style selectors via \`definition.styleSelectors\`:
-
-\`\`\`typescript
-// element.definition.styleSelectors
-{
-  base: '.hero-section',    // Points to style.platform.desktop['.hero-section']
-  title: '.hero-title'      // Points to style.platform.desktop['.hero-title']
-}
-\`\`\`
-
-## Display Modes
-
-A style selector can exist in multiple display modes (\`desktop\`, \`tablet\`, \`mobile\`). Rules in \`tablet\` and \`mobile\` override the desktop base at their respective breakpoints.
-
-## Common Operations
-
-- \`create_style_selector\` — add a new StyleItem to a display mode.
-- \`update_style_selector\` — modify \`attributes\` for an existing selector.
-- \`delete_style_selector\` — remove a selector from a display mode.
-`
-};
-//#endregion
-export { styleSelectorResource };

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

@@ -1,72 +0,0 @@
-//#region src/modules/mcp/resources/glossary/styleVariable.ts
-var styleVariableResource = {
-	uri: "plitzi://docs/style-variable",
-	name: "Plitzi Docs: Style Variable",
-	description: "Design tokens in the Plitzi style system — reusable values for colors, spacing, shadows, and custom properties.",
-	mimeType: "text/markdown",
-	content: `# Style Variable
-
-**Style variables** are design tokens stored in the \`Style\` object. They define reusable values (colors, spacing units, shadows, custom properties) that can be referenced across all CSS rules in the space.
-
-## TypeScript Shape
-
-\`\`\`typescript
-enum StyleVariableCategory {
-  COLOR = 'color',
-  SPACING = 'spacing',
-  SHADOW = 'shadow',
-  CUSTOM = 'custom'
-}
-
-type StyleVariables = Record<StyleVariableCategory, StyleVariableGroup>;
-type StyleVariableGroup = Record<string, StyleVariableValue>;
-
-// Value can be a plain string/number or theme-aware (different per light/dark)
-type StyleVariableValue =
-  | string
-  | number
-  | {
-      light?: string;
-      dark?: string;
-      default?: string;
-    };
-\`\`\`
-
-## Categories
-
-- **\`color\`** — color tokens (e.g. \`primary\`, \`background\`, \`text-muted\`). Values can be theme-aware (different for light vs. dark).
-- **\`spacing\`** — spacing units (e.g. \`sm\`, \`md\`, \`lg\`). Plain numbers or CSS values.
-- **\`shadow\`** — box-shadow definitions (e.g. \`card\`, \`modal\`).
-- **\`custom\`** — any other token (border radius, font size, z-index, etc.).
-
-## Theme-Aware Values
-
-When a design system supports multiple themes, a variable value can vary:
-
-\`\`\`typescript
-{ light: '#ffffff', dark: '#1a1a1a', default: '#ffffff' }
-\`\`\`
-
-The \`default\` key is used when no theme preference is detected.
-
-## Scope
-
-Variables can be scoped at two levels:
-
-1. **Style-level** (\`style.variables\`) — global tokens available everywhere in the space.
-2. **Selector-level** (\`styleItem.variables\`) — tokens scoped to one CSS selector (override global for that component).
-
-## Common Operations
-
-- \`create_style_variable\` — add a new token with a category and name.
-- \`update_style_variable\` — change a token's value.
-- \`delete_style_variable\` — remove a token.
-
-## Relationships
-
-- Referenced by **Style Selectors** via CSS variable syntax or direct value interpolation.
-- **Schema Variables** are different — they are schema-level data variables, not CSS design tokens.
-`
-};
-//#endregion
-export { styleVariableResource };

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

@@ -1,71 +0,0 @@
-import { bindingResource } from "./glossary/binding.js";
-import { collectionResource } from "./glossary/collection.js";
-import { displayModeResource } from "./glossary/displayMode.js";
-import { elementResource } from "./glossary/element.js";
-import { environmentResource } from "./glossary/environment.js";
-import { interactionResource } from "./glossary/interaction.js";
-import { pageResource } from "./glossary/page.js";
-import { pluginResource } from "./glossary/plugin.js";
-import { resourceResource } from "./glossary/resource.js";
-import { schemaResource } from "./glossary/schema.js";
-import { schemaVariableResource } from "./glossary/schemaVariable.js";
-import { segmentResource } from "./glossary/segment.js";
-import { spaceResource } from "./glossary/space.js";
-import { styleResource } from "./glossary/style.js";
-import { styleSelectorResource } from "./glossary/styleSelector.js";
-import { styleVariableResource } from "./glossary/styleVariable.js";
-import { workflowDataResource } from "./workflows/data.js";
-import { workflowElementsResource } from "./workflows/elements.js";
-import { workflowSegmentsResource } from "./workflows/segments.js";
-import { workflowStylesResource } from "./workflows/styles.js";
-//#region src/modules/mcp/resources/index.ts
-var glossaryResources = [
-	schemaResource,
-	elementResource,
-	pageResource,
-	styleResource,
-	styleSelectorResource,
-	styleVariableResource,
-	segmentResource,
-	pluginResource,
-	collectionResource,
-	spaceResource,
-	environmentResource,
-	schemaVariableResource,
-	resourceResource,
-	bindingResource,
-	interactionResource,
-	displayModeResource
-];
-var workflowResources = [
-	workflowElementsResource,
-	workflowStylesResource,
-	workflowSegmentsResource,
-	workflowDataResource
-];
-var registerResources = (server, custom = [], onRead) => {
-	for (const r of [
-		...glossaryResources,
-		...workflowResources,
-		...custom
-	]) server.registerResource(r.name, r.uri, {
-		description: r.description,
-		mimeType: r.mimeType
-	}, () => {
-		onRead?.(r.name, r.uri);
-		return { contents: [{
-			uri: r.uri,
-			mimeType: r.mimeType,
-			text: r.content
-		}] };
-	});
-};
-var allResources = [...glossaryResources, ...workflowResources];
-var getResourceList = () => allResources.map(({ uri, name, description }) => ({
-	uri,
-	name,
-	description
-}));
-var getResourceByUri = (uri) => allResources.find((r) => r.uri === uri);
-//#endregion
-export { allResources, getResourceByUri, getResourceList, registerResources };