@cplace/mcp-server 1.3.14

package/dist/widget-specifications/cf.cplace.tableDetailViewWidget.widget/_overview.md

@@ -0,0 +1,92 @@
+## Legacy Notice
+
+**This widget is considered legacy.** For new implementations, use `cf.cplace.platform.connectedAttributesGroup` (Grouped Attributes of a Table) instead, which offers:
+- Flexible embedded layout (vs. fixed 3-column)
+- Inline editing support (vs. read-only only)
+- Part of core platform (vs. separate plugin)
+
+This widget remains functional for existing implementations but is not recommended for new master-detail layouts.
+
+---
+
+## Overview
+
+The Page Details widget dynamically displays attributes of a selected table entry and therefore requires a table. It creates a master-detail interface by displaying selected attributes of a page chosen from a connected table widget. The detail panel automatically updates when users select different rows in the table, showing a configurable set of attributes in a structured layout.
+
+This widget implements the classic master-detail UI pattern where a table widget (the master) shows multiple rows of data, and this widget (the detail) shows comprehensive information about the selected row. The synchronization is automatic - clicking a table row instantly updates the detail view.
+
+## Use Cases
+
+### When to Use This Widget
+
+**Space-Constrained Table Views**
+When a table has many columns that don't all fit comfortably on screen, use this widget to show key columns in the table while displaying detailed attributes in the detail panel. For example, a project list might show only name and status in the table, with full details (description, dates, owner, budget) appearing in the detail panel.
+
+**Read-Only Detail Information**
+Ideal for displaying additional context about a selected item without providing editing capabilities. Use when users need to review details but not modify them, such as viewing full specifications of a product selected from a catalog table.
+
+**Dashboard and Reporting Layouts**
+Create dashboard pages with table plus detail layouts, or master-detail reports where the table provides overview and the detail provides depth. For example, a risk register showing all risks in a table, with detailed risk assessment displayed when a risk is selected.
+
+**Improved User Experience**
+Avoid navigation away from the current page to see details, keeping users in context while browsing list data. Provides quick preview of full information without opening separate pages, such as a task list where selecting a task shows its full description and metadata.
+
+**Structured Information Display**
+Show related but categorized information when details are too verbose for table columns but important to have readily accessible. For example, incident management where the table shows incident titles and status, while the detail panel shows full description, timestamps, and involved parties.
+
+### Problem This Widget Solves
+
+The widget addresses the challenge of displaying detailed information from tables without overwhelming the table view or requiring navigation:
+
+- **Limited horizontal space**: Tables with many columns become unwieldy and hard to scan
+- **Information density**: Users need both overview (table) and details simultaneously
+- **Navigation overhead**: Opening individual pages disrupts workflow and context
+- **Context switching**: Users want to browse multiple items quickly without leaving the page
+
+It provides a responsive detail panel that keeps users on the same page while exploring data, combining efficient scanning of list data with instant access to comprehensive details.
+
+## Design Considerations
+
+### Display Layout
+
+The widget uses a fixed 3-column layout for displaying attributes:
+- Attributes are automatically distributed across three columns using modulo logic
+- Each attribute is shown with its label and value
+- Optional header section can display rich text content above the attributes
+- All attributes are displayed in read-only mode (no in-place editing)
+
+### Initial Selection Behavior
+
+When the page first loads, if no table row has been explicitly selected, the widget displays attributes for the first entry from the connected table's search results. This ensures the detail panel always shows something useful rather than being empty.
+
+### Event-Driven Architecture
+
+The widget listens for row selection events from the connected table widget and updates its content dynamically via AJAX. This creates a seamless, responsive experience without page reloads.
+
+## Common Pitfalls
+
+- **Same-Page Requirement**: The table and detail widgets must be on the same page. You cannot connect to tables on other pages or workspaces.
+- **Read-Only Limitation**: This widget displays attributes in read-only mode. If you need editing capabilities, consider using the Tuples Widget instead.
+- **Fixed Layout**: The 3-column layout is not configurable. You cannot adjust to 1, 2, or 4 columns.
+- **Single Selection Only**: The widget shows details for only one selected page at a time. Multi-selection is not supported.
+
+## Related Widgets
+
+**cf.cplace.platform.tableWidget** (Table Widget)
+Required companion widget that serves as the master in the master-detail relationship. The table provides the list of pages, and this widget displays details of the selected item.
+
+**cf.platform.embeddedSearchAsTable** (Embedded Search as Table)
+Can be used as the master table widget, displaying search results in table format with details shown in this widget when a result is selected.
+
+**cf.cplace.tuplesWidget.widget** (Tuples Widget)
+Alternative when editing is required. Tuples Widget provides inline editing capabilities and CRUD operations on references, while Page Details is read-only and focused on viewing details.
+
+**cf.cplace.platform.connectedAttributesGroup** (Connected Attributes Group)
+Different use case - shows attributes of a fixed referenced page (static 1-to-1 relationship), while Page Details shows attributes of a dynamically selected table row.
+
+## Alternatives
+
+- If you need **editing capabilities** for the selected item, use the **Tuples Widget** which supports inline editing and CRUD operations.
+- If you need to display attributes of a **static referenced page** (not table-driven selection), use the **Connected Attributes Group** widget.
+- If you want to display all attributes of the **current embedding page** itself, use the **Attributes Widget** instead.
+- If you need a **custom layout** or more than 3 columns, consider building a custom low-code widget with the desired layout.

package/dist/widget-specifications/cf.cplace.tableDetailViewWidget.widget/_summary.md

@@ -0,0 +1 @@
+**Legacy widget** - prefer `cf.cplace.platform.connectedAttributesGroup` for new implementations. Displays attributes of a selected table row in a fixed 3-column read-only layout. Use the preferred alternative for flexible layouts and inline editing.

package/dist/widget-specifications/cf.cplace.tableDetailViewWidget.widget/attributes.md

@@ -0,0 +1,7 @@
+**Warning**: Custom attribute names must use their fully qualified internal names.
+
+**Value Format**:
+- **Custom attributes**: Use fully qualified names like `'cf.cplace.solution.taskTitle'`
+- **Built-in attributes**: Use simple feature names like `name`, `creator`, `created`
+
+**Note**: The enumeration provider dynamically populates available attributes based on the connected table widget's type. Only attributes from the table's result type are selectable.

package/dist/widget-specifications/cf.cplace.treeTableWidget/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.treeTableWidget",
+  "Description": "{\"en\":\"Table with tree functionality\",\"de\":\"Tabelle mit Baumfunktionalität\"}",
+  "Localized Name": "{\"en\":\"Tree-structure Table\",\"de\":\"Baumstruktur-Tabelle\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.treeTableWidget",
+  "App": "cf.cplace.treeTableWidget",
+  "Localized App Name": "{\"en\":\"Tree-structure Table\",\"de\":\"Baumstruktur-Tabelle\"}",
+  "Repository": "cplace-utility-widgets",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.treeTableWidget/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "tree",
+    "table",
+    "references",
+    "navigation",
+    "filterable",
+    "selectable"
+  ],
+  "requiredApp": "cf.cplace.treeTableWidget"
+}

package/dist/widget-specifications/cf.cplace.treeTableWidget/_overview.md

@@ -0,0 +1,51 @@
+## Overview
+
+The Tree-structure Table widget provides a table with tree functionality. It displays hierarchical page relationships in a combined tree-table format, enabling users to navigate through parent-child page structures while viewing associated attribute data in configurable columns. The widget supports expand/collapse functionality for tree nodes and includes a rich context menu with common page operations.
+
+This widget is a concrete implementation of the platform's abstract `TreeTableWidgetDefinition`, providing ready-to-use functionality without requiring custom frontend development. It leverages 100% platform rendering capabilities for reliability and maintainability.
+
+## Use Cases
+
+### Project and Work Breakdown Structures
+Display project hierarchies with tasks, sub-tasks, and deliverables. Navigate through complex project organizations and work package breakdowns in a structured format.
+
+### Organizational Hierarchies
+Visualize organizational structures including departments, teams, and roles. Display reporting relationships and navigate through organizational units.
+
+### Document and Content Hierarchies
+Show document folder structures and content hierarchies such as chapters, sections, and sub-sections. Useful for navigating through knowledge bases.
+
+### Product and Component Structures
+Display product hierarchies, component breakdowns, and system architectures. Navigate through technical structures and dependencies.
+
+### Navigation and Overview Pages
+Create dashboard pages with hierarchical navigation, provide overview pages showing entire page structures, and serve as entry points to complex information architectures.
+
+## Design Considerations
+
+### When to Use
+- Displaying parent-child page relationships with associated data columns
+- Users need to navigate through multi-level hierarchies efficiently
+- Combining tree navigation with tabular data display
+- Quick access to context menu actions on hierarchical items is valuable
+
+### When Not to Use
+- Simple lists without hierarchy (use Table widget instead)
+- Data without parent-child relationships (use regular Table widget)
+- Complex custom interactions that exceed platform rendering capabilities
+
+### Configuration Requirements
+- Pages must have a parent-child relationship attribute defined
+- At least one attribute must be configured for column display
+- Search configuration defines which page types appear in the tree
+- Default depth setting affects initial load performance for large hierarchies
+
+### Context Menu Features
+The widget provides context menu actions including: New Subpage, Open in New Tab, Expand All Children, Copy, Move, and Delete. These actions require appropriate user permissions.
+
+## Related Patterns and Alternatives
+
+- **Table Widget** (`cf.cplace.platform.tableWidget`): For flat data without hierarchical relationships
+- **Extended Tree Table Widget** (`cf.cplace.extendedTreeTableWidget`): For more advanced tree-table configurations
+- **Tree widgets**: When only tree navigation is needed without tabular data columns
+- **Connected Table Filter**: For tables with external filtering capabilities

package/dist/widget-specifications/cf.cplace.treeTableWidget/_summary.md

@@ -0,0 +1 @@
+Table with tree functionality that displays hierarchical page structures with expandable/collapsible nodes and configurable data columns. Combines tree navigation for parent-child relationships with tabular data display.

package/dist/widget-specifications/cf.cplace.tuplesWidget.widget/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.tuplesWidget.widget",
+  "Description": "{\"de\":\"Zeigt die Tupel-Seiten innerhalb einer Tabelle.\",\"en\":\"Shows the tuple pages within a table.\"}",
+  "Localized Name": "{\"en\":\"Tuple\",\"de\":\"Tupel\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.tuplesWidget",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace-paw",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details</strong></p>\n\n<p>The 'Tuples' widget can be used to create and edit tuple-type data.</p>\n\n<p>Tuples are finite ordered lists of elements. Unlike lists, tuples are immutable.</p>\n\n<p><strong>Settings</strong></p>\n\n<p>// * Tuple attribute:</p>\n\n<p>// * Show name of tuple as column *: True/false.</p>\n\n<p>// * Attributes of tuples to be shown in widget:</p>\n\n<p>// * Sort by:</p>\n\n<p>// * Sort order:</p>\n\n<p>// * Widget title: Bilingual text.</p>\n\n<p>// * Height of the widget (in pixels)</p>\n\n<p>// * Allow reordering of tuple entries<span class=\"cplace-control-required\"> *: True/false.&nbsp;</span> If this option is enabled and if the user has the permission to edit the tuple attribute, the widget will show buttons for&nbsp; reordering the tuple entries. This option cannot be used in combination with 'Sort by'.</p>\n\n<p><span class=\"cplace-control-required\">// </span> * Allow the creation of tupel entries<span class=\"cplace-control-required\"> *:&nbsp;True/false.</span>&nbsp; If this option is enabled and if the user has the permission to create pages of the tuple type, the widget will show a button for creating new tuple entries.</p>\n\n<p><span class=\"cplace-control-required\">// * </span> Allow editing of tupel entries <span class=\"cplace-control-required\">*</span>: <span class=\"cplace-control-required\">True/false. </span> If this option is enabled and if the user has the permission to edit a tuple entry, its attributes will be editable within the widget.</p>\n\n<p>// * Allow deletion of tupel entries <span class=\"cplace-control-required\">*</span>: <span class=\"cplace-control-required\">True/false. </span> If this option is enabled and if the user has the permission to delete a tuple entry, the widget will show a button for deleting it.</p>"
+}

package/dist/widget-specifications/cf.cplace.tuplesWidget.widget/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "table",
+    "references",
+    "inline-edit",
+    "sortable",
+    "drag-drop",
+    "detail-view"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.cplace.tuplesWidget.widget/_overview.md

@@ -0,0 +1,202 @@
+## Overview
+
+The Tuple widget shows the tuple pages within a table. It provides a specialized table view for managing collections of referenced pages (called "tuples") through a multi-reference attribute. It combines viewing, inline editing, and CRUD operations in a spreadsheet-like interface without requiring users to navigate away from the parent page.
+
+In cplace terminology, "tuples" are referenced entities (pages) linked to the current page through a reference attribute. This widget displays these referenced pages with configurable columns showing selected attributes from the referenced type.
+
+## Use Cases
+
+### Master-Detail Relationships
+Display and manage a list of related detail records for a master record.
+- **Example**: A project page showing related tasks, risks, or milestones
+- **Example**: A customer page displaying contacts or orders
+- **Benefit**: All related items visible and editable in one place
+
+### Structured Data Collections
+Manage collections of structured data entries where multiple attributes of each item need to be visible.
+- **Example**: Configuration items, checklist entries, or requirements
+- **Benefit**: Table format provides quick scanning of multiple data points per item
+
+### Editable Reference Lists
+When users need to create, edit, and delete referenced items directly from the parent page.
+- **Benefit**: Inline editing without navigation
+- **Benefit**: Quick creation of new related entities
+- **Benefit**: Integrated deletion with confirmation
+
+### Ordered Collections
+When the sequence of referenced items matters and users need to reorder them.
+- **Feature**: Drag-and-drop reordering
+- **Feature**: Manual ordering controls (up/down buttons)
+- **Benefit**: Maintains user-defined sequence in the reference attribute
+
+### Configurable Views of Related Data
+Show only specific attributes of referenced items tailored to the use case.
+- **Feature**: Custom column selection from available tuple attributes
+- **Benefit**: Focused view without information overload
+- **Benefit**: Adapts to different viewing contexts
+
+## Operating Modes
+
+The widget has two mutually exclusive ordering modes:
+
+### Manual Ordering Mode
+**Enabled when**: Reordering is allowed AND no sort attribute is configured
+
+Users can drag-and-drop or use up/down buttons to reorder tuples. The order is persisted in the reference attribute and maintained across sessions.
+
+**Requirements**:
+- User must have edit permission on the tuple attribute
+- At least 2 tuples must exist
+- Automatic sorting must not be configured
+
+### Automatic Sorting Mode
+**Enabled when**: A sort attribute is configured
+
+Tuples are automatically sorted by the specified attribute in ascending or descending order. Users cannot manually change the order.
+
+**Note**: This mode and manual ordering mode cannot be used together.
+
+## Design Considerations
+
+### When to Use This Widget
+
+**Choose Tuples Widget when**:
+- You need to manage a moderate collection of referenced entities (typically < 100 items)
+- Users need inline editing capabilities for referenced items
+- The relationship is managed through a reference attribute on the embedding page
+- CRUD operations on referenced items are important to the workflow
+- Column-based view of multiple attributes is valuable
+
+**Consider Alternatives when**:
+- You need complex filtering or aggregation (use Embedded Search Table)
+- The collection is very large (> 100 items) (use Embedded Search Table)
+- You only need read-only display (use Table Widget or Embedded Search)
+- The relationship is single-valued 1-to-1 (use Connected Attributes Group)
+- You need cross-workspace searches (use Embedded Search)
+
+### Permission-Aware Design
+
+The widget adapts its UI based on user permissions and configuration:
+
+1. **Allow Reordering**: Shows/hides ordering controls based on configuration and permissions
+2. **Allow Adding**: Shows/hides "Create [Type]" button based on create permissions and multiplicity
+3. **Allow Editing**: Enables/disables inline editing based on edit permissions
+4. **Allow Deleting**: Shows/hides delete buttons based on delete permissions
+
+This granular control allows precise definition of user capabilities at the widget level.
+
+### Configuration Dependencies
+
+Key configuration flow:
+1. First select the reference attribute (Tuple Attribute)
+2. Save configuration to refresh available options
+3. Then select which tuple attributes to display as columns
+4. Configure ordering mode (manual OR automatic, not both)
+5. Set permission toggles based on intended user interaction
+
+**Important**: The list of available tuple attributes for column selection only becomes available after selecting and saving the reference attribute.
+
+## Common Pitfalls
+
+### Trying to Use Both Ordering Modes
+**Problem**: Configuring both manual reordering and automatic sorting simultaneously.
+
+**Solution**: Choose one mode. If sorting is needed, use automatic sorting. If user-defined order is needed, enable manual reordering without configuring a sort attribute.
+
+### Not Saving After Selecting Reference Attribute
+**Problem**: Attempting to configure visible columns before saving the reference attribute selection.
+
+**Solution**: Save the widget configuration after selecting the tuple attribute to refresh the available column options.
+
+### Using for Large Collections
+**Problem**: Performance issues when displaying hundreds of tuples.
+
+**Solution**: For large collections, use Embedded Search Table widget which provides pagination and is optimized for larger datasets.
+
+### Insufficient Permissions
+**Problem**: Users cannot perform expected operations (create, edit, delete, reorder).
+
+**Solution**: Verify users have:
+- Edit permission on the reference attribute (for add/remove/reorder)
+- Create permission on tuple type (for adding)
+- Edit permission on individual tuples (for inline editing)
+- Delete permission on individual tuples (for deletion)
+
+### Overlooking Multiplicity Constraints
+**Problem**: Users cannot add tuples when maximum multiplicity is reached.
+
+**Solution**: Check the reference attribute's multiplicity settings. If set to single-valued or has a maximum, the widget will prevent additional additions.
+
+## Related Widgets
+
+### Connected Attributes Group (`cf.cplace.platform.connectedAttributesGroup`)
+Shows attributes of a single referenced entity in form layout.
+
+**Use Connected Attributes when**: You have a 1-to-1 relationship and need to display/edit attributes of a single referenced page.
+
+**Use Tuples Widget when**: You have a 1-to-many relationship and need table-based view of multiple referenced pages.
+
+### Embedded Search Table (`cf.platform.embeddedSearchAsTable`)
+Shows search results in table format with advanced filtering and aggregation.
+
+**Use Embedded Search when**: You need complex filtering, large datasets, cross-space searches, aggregations, or read-only display of query results.
+
+**Use Tuples Widget when**: You need CRUD operations, inline editing, manual ordering, or direct reference management through an attribute.
+
+### Table Widget (`cf.cplace.platform.tableWidget`)
+Generic table for displaying structured data.
+
+**Use Table Widget when**: You need a simple read-only table display of data.
+
+**Use Tuples Widget when**: You need interactive management of referenced entities with editing and CRUD capabilities.
+
+### Table Detail View Widget (`cf.cplace.tableDetailViewWidget.widget`)
+Shows table with expandable detail panels.
+
+**Use Table Detail View when**: You need master-detail layout with expandable detail panels showing more information than fits in columns.
+
+**Use Tuples Widget when**: You need simpler table-based reference management without detail panels.
+
+## Key Differences from Similar Widgets
+
+### vs. Embedded Search Table
+- **Tuples Widget**: Direct reference management, inline editing, CRUD operations, manual ordering, works through reference attribute
+- **Embedded Search**: Read-only view, complex filtering, cross-space searches, aggregations, pagination for large datasets
+
+### vs. Connected Attributes Group
+- **Tuples Widget**: Multiple referenced entities in table format
+- **Connected Attributes**: Single referenced entity with form layout
+
+### vs. Table Detail View
+- **Tuples Widget**: Simpler table-focused interface with inline editing
+- **Table Detail View**: More complex layout with expandable detail views
+
+## Prerequisites
+
+### Data Model Requirements
+1. A reference attribute must exist on the embedding page's type
+2. The reference attribute must point to a specific tuple type
+3. The tuple type should have attributes that make sense to display in columns
+4. Multi-value multiplicity (0..* or similar) for the reference attribute
+
+### Permission Requirements
+1. Read access to the tuple type and its attributes
+2. Edit access to the reference attribute (for add/remove/reorder operations)
+3. Create permissions on tuple type (for creation operations)
+4. Delete permissions on tuple type (for deletion operations)
+
+### Embedding Context
+The widget must be embedded in a Page or TypeDefinition. It cannot be embedded in other contexts.
+
+## Extension Points
+
+The widget provides several extension points for custom behavior:
+
+### AssignReferenceToNewTupleExtension
+Add custom search filters when creating new tuples to restrict which tuples can be created based on business logic.
+
+### TupleValidationErrorExtension
+Show custom error messages or warnings about the tuple collection in the widget UI.
+
+### PreventRemoveTupleExtension
+Prevent deletion of specific tuples to protect required tuples or enforce business rules.

package/dist/widget-specifications/cf.cplace.tuplesWidget.widget/_summary.md

@@ -0,0 +1 @@
+Shows the tuple pages within a table. Displays referenced entities with inline editing capabilities and CRUD operations for managing collections of related pages through reference attributes.

package/dist/widget-specifications/cf.cplace.videoWidget/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.videoWidget",
+  "Description": "{\"en\":\"Enables output of a previously selected video uploaded to cplace.\",\"de\":\"Ermöglicht die Ausgabe eines zuvor gewählten und in cplace hochgeladenen Videos.\"}",
+  "Localized Name": "{\"en\":\"Video\",\"de\":\"Video\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.videoWidget",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace-utility-widgets",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.videoWidget/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "media",
+    "files",
+    "read-only",
+    "detail-view",
+    "documentation"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.cplace.videoWidget/_overview.md

@@ -0,0 +1,65 @@
+## Overview
+
+The Video widget enables output of a previously selected video uploaded to cplace. It provides a simple way to embed video and image content directly on cplace pages using the browser's native HTML5 video player, providing standard controls (play, pause, volume, fullscreen) without requiring external video hosting services. The widget automatically detects whether the uploaded file is a video or image and renders it appropriately with configurable dimensions and optional frame styling.
+
+## Use Cases
+
+**Educational Content**: Display instructional or training videos directly on project pages or documentation pages for team learning and knowledge transfer.
+
+**Presentations & Demos**: Embed product demos, feature walkthroughs, or presentation recordings to showcase functionality without leaving cplace.
+
+**Documentation**: Add visual content (videos or images) to enhance written documentation and make processes clearer.
+
+**Media Galleries**: Create visual portfolios or media collections on pages to organize and display multimedia content.
+
+**Team Communication**: Share recorded meetings, status updates, or announcements in video format for asynchronous collaboration.
+
+**Marketing Materials**: Display promotional videos, case studies, or customer testimonials within cplace pages.
+
+### When to Use This Widget
+
+- When you need to embed video or image content directly on a cplace page without external hosting
+- When you want browser-native video controls without additional configuration
+- When you need responsive video display that adapts to container width
+- When you want a simple, no-configuration-needed media display solution
+- When you need to support offline scenarios where external video hosting isn't available
+
+## Design Considerations
+
+### Why This Widget Exists
+
+The Video Widget leverages native HTML5 capabilities for better performance and privacy compared to external video services. It maintains consistent styling with cplace's widget framework and supports offline scenarios where external video hosting like YouTube or Vimeo isn't available or desirable.
+
+### Limitations
+
+The widget has intentional constraints focused on simplicity:
+
+- No advanced video player features (chapters, subtitles, playback speed controls)
+- Relies on browser's native video codec support, which varies by browser
+- Files must be uploaded to cplace (no direct URL embedding to external sources)
+- Width is always responsive (100% of container), cannot set fixed width
+- Height is fixed in pixels rather than responsive
+
+### Browser Compatibility
+
+The widget requires HTML5 video support in the browser. For unsupported browsers, it displays a fallback message: "Your browser does not support the video tag."
+
+## Alternatives
+
+Consider alternatives when this widget doesn't fit your needs:
+
+**For YouTube/Vimeo videos**: Use an iframe widget or embed widget instead of uploading the file to cplace.
+
+**For complex video interactions**: Custom development may be needed if you require advanced features like chaptered navigation, multi-language subtitles, or custom player controls.
+
+**For streaming large video files**: Consider external hosting platforms optimized for streaming to avoid storage and bandwidth constraints.
+
+**For live video**: Requires a different streaming solution; this widget only supports uploaded files.
+
+## Related Patterns
+
+**Documentation Enhancement**: Combine the Video Widget with text widgets and structured content to create rich, multimedia documentation pages.
+
+**Media Collections**: Use multiple Video Widgets within a layout to create galleries or comparison views.
+
+**Training Materials**: Pair with form widgets or interactive elements to create training modules with embedded video demonstrations.

package/dist/widget-specifications/cf.cplace.videoWidget/_summary.md

@@ -0,0 +1 @@
+Enables output of a previously selected video uploaded to cplace. Displays video files and images with customizable dimensions and optional frame styling using HTML5 video player controls.

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.visualizations.scriptingHighcharts",
+  "Description": "{\"de\":\"Ermöglicht die Konfiguration von Highchart-Diagrammen mittels cplaceJS.\",\"en\":\"Enables the configuration of Highchart diagrams using cplaceJS.\"}",
+  "Localized Name": "{\"en\":\"cplaceJS based Highcharts Visualization\",\"de\":\"cplaceJS Highcharts-Diagramm\"}",
+  "Icon": "cf-cplace",
+  "Plugin": "cf.cplace.scriptingVisualizations",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace-paw",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/_implementation.md

@@ -0,0 +1,12 @@
+**Configuration Modes**: The widget has these data source modes controlled by `cf.cplace.visualization.dataSource`:
+- `search`: Query pages via embedded search
+- `connectedTable`: Use pages from another table widget on the same layout
+
+**Typical Configuration Workflow**:
+1. Set `cf.cplace.visualization.dataSource` to choose your data source mode
+2. Configure the corresponding data source attribute:
+   - For `search`: Configure `cf.cplace.visualization.search` (use cplaceJson from cplace_search_pages)
+   - For `connectedTable`: Set `tableWidgetId` and `cf.cplace.visualization.tableSelectionOnly`
+3. Write your cplaceJS script in `cf.cplace.visualization.script` that:
+   - Processes the `pages` variable (all pages from your data source)
+   - Returns a valid Highcharts configuration object

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/_meta.json

@@ -0,0 +1,9 @@
+{
+  "tags": [
+    "chart",
+    "low-code",
+    "dashboard",
+    "filterable"
+  ],
+  "requiredApp": null
+}