@cplace/mcp-server 1.3.14

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

@@ -0,0 +1,117 @@
+## Overview
+
+The cplaceJS based Highcharts Visualization widget enables the configuration of Highchart diagrams using cplaceJS. It serves as the escape hatch when standard chart widgets cannot meet visualization requirements.
+
+**Use when**:
+- Standard chart widgets (pie, bar, line) lack required customization
+- You need complex chart types like Gantt charts, mixed-type charts, or specialized layouts
+- Visualization logic requires conditional formatting, custom tooltips, or dynamic data transformations
+- Charts must respond to specific business rules or calculations
+
+**Alternatives**:
+- **Connected Pie Chart** - Simpler pie/donut charts without scripting
+- **Connected Bar Chart** - Standard bar/column visualizations
+- **Scripting Line Chart** - When only line charts are needed with simpler scripting
+
+## Use Cases
+
+### Timeline and Scheduling Visualizations
+Gantt charts displaying projects, tasks, or activities across time. These require mapping start/end dates to horizontal bars, applying status-based coloring, and often include clickable elements linking to detail pages.
+
+### Status Distribution Displays
+Donut or pie charts showing how items distribute across different states (open/in progress/done, risk levels, categories). Useful for dashboards where stakeholders need quick visual summaries.
+
+### Trend Analysis with Comparisons
+Mixed chart types combining stacked columns with overlaid line series. Common for comparing actual values against targets, demand versus capacity, or historical trends against forecasts.
+
+### Resource and Capacity Views
+Visualizations aggregating time-bounded data across periods (monthly, quarterly). Often requires processing complex reference chains and calculating derived metrics.
+
+## Behavior and Capabilities
+
+### Data Source Modes
+
+The widget supports two fundamentally different data retrieval approaches:
+
+**Connected Table Mode**: The chart receives its data from a table widget on the same page. This creates a tight coupling where the chart always reflects what the table shows, including any filters or sorting the user has applied. Users can optionally restrict the chart to only selected rows, enabling interactive exploration.
+
+**Search Mode**: The chart queries for data independently using cplace's search filters. This provides flexibility when the chart needs different data than surrounding widgets, or when there is no table to connect to.
+
+### Scripting Capabilities
+
+Scripts receive page data and must return a valid Highcharts configuration object. Within the script, you can:
+
+- Access page attributes including references and their nested properties
+- Perform aggregations and calculations across the dataset
+- Apply conditional logic for colors, labels, and formatting
+- Generate clickable elements linking to pages
+- Handle localization based on user language
+- Implement empty-state handling when no data matches criteria
+
+### Highcharts Integration
+
+The widget supports the full range of Highcharts chart types and configurations:
+- Standard charts (column, bar, line, pie, area)
+- Gantt charts with timeline axes
+- Mixed-type charts combining multiple series types
+- Custom tooltips, data labels, and legends
+- Interactive features like zoom and click handlers
+
+## Design Considerations
+
+### When Scripting is Worth the Complexity
+
+Scripting adds maintenance overhead and requires JavaScript knowledge. Choose this widget when:
+
+- The visualization logic cannot be expressed through configuration alone
+- You need to combine or transform data from multiple attributes
+- Status-to-color mapping requires business logic beyond simple lookups
+- The chart type or layout is not available in standard widgets
+
+For straightforward distributions or comparisons, standard chart widgets are preferable.
+
+### When NOT to Use This Widget
+
+**For simple number displays (KPI cards, metric counts), use `demoRichString` instead:**
+
+- No Highcharts configuration needed
+- Full CSS control over card styling
+- Lower complexity for basic number + label displays
+- Platform widget - always available
+
+| Need | Better Choice |
+|------|---------------|
+| Single number with label (KPI card) | `demoRichString` |
+| Styled metric with custom colors | `demoRichString` |
+| Count from search query | `demoRichString` with embedded Low-Code widget |
+
+Use this widget only when you need actual charts (bar, pie, line, Gantt, gauge).
+
+### Data Volume Implications
+
+Scripts execute on page load and process data client-side. For large datasets:
+- Consider server-side aggregation before visualization
+- Use specific search filters to limit returned data
+- Avoid complex nested reference traversals on large result sets
+
+### Empty State Handling
+
+Scripts should always handle the case where no data matches the search criteria. Returning a centered message rather than a broken or empty chart improves user experience significantly.
+
+### Mixed Chart Considerations
+
+When combining series types (e.g., columns with a line overlay), layer ordering matters. Line series typically need higher z-index values to appear above filled series. Step-style lines often work better than smooth curves when overlaying discrete column data.
+
+### Localization
+
+Charts displayed to international users should detect user language and provide localized labels, titles, and messages. This includes both static text and dynamically generated content like tooltips.
+
+## Related Widgets
+
+**Data Source Widgets**: Works with **Table Widget** or **Connected Table** when using connected table mode. The table defines what data flows into the chart.
+
+**Alternative Chart Widgets**: Consider **Connected Pie Chart** and **Connected Bar Chart** for simpler requirements. These offer less flexibility but require no scripting.
+
+**Sibling Scripting Widget**: **Scripting Line Chart** provides similar scripting capabilities but optimized specifically for line chart rendering.
+
+**Dashboard Context**: Often appears alongside summary widgets, KPI displays, and tables to provide complementary visualizations of the same underlying data from different perspectives.

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

@@ -0,0 +1 @@
+Enables the configuration of Highchart diagrams using cplaceJS. Use when standard chart widgets lack required customization for complex chart types, conditional formatting, or business-rule-driven visualizations.

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

@@ -0,0 +1,5 @@
+**Valid Values**:
+- `search`: Widget queries data via embedded search
+  - Activates: `cf.cplace.visualization.search`, `sortColumn`, `sortOrder`
+- `connectedTable`: Widget uses data from a connected table widget
+  - Activates: `tableWidgetId`, `cf.cplace.visualization.tableSelectionOnly`

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

@@ -0,0 +1,10 @@
+**Warning**: Do not manually construct search JSON!
+
+**Correct Usage**: Use the `cplaceJson` field from `cplace_search_pages` response.
+
+**Workflow**:
+1. Call `cplace_search_pages` with your desired filter
+2. Take the `cplaceJson` field from the response
+3. Use that value for this attribute
+
+**Note**: Only active when `cf.cplace.visualization.dataSource` = `search`. The search results become available to the cplaceJS script as the `pages` variable.

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

@@ -0,0 +1,29 @@
+**Warning**: The script must return a valid Highcharts configuration object!
+
+**Available Bindings** (variables accessible in your script):
+
+| Variable | Type | Description |
+|----------|------|-------------|
+| `embeddingPage` | `WrappedPage` | The page in which the Highchart widget is embedded |
+| `pages` | `Iterable<WrappedPage>` | All pages from the configured data source |
+| `messages` | Message Provider | Helper to access localized messages from the embedding page's type definition |
+
+**Additional Allowed Classes**:
+- `Search.class` - For creating additional searches
+- `Filters.class` - For creating search filters
+
+**Expected Return**: A valid Highcharts configuration object (JSON-compatible). See [Highcharts API](https://api.highcharts.com/highcharts/).
+
+**Example**:
+```javascript
+var configuration = {
+    chart: { type: 'bar' },
+    title: { text: 'My Chart' },
+    xAxis: { categories: ['A', 'B', 'C'] },
+    series: [{
+        name: 'Series 1',
+        data: [1, 2, 3]
+    }]
+};
+return configuration;
+```

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

@@ -0,0 +1,10 @@
+**Note**: Only active when `cf.cplace.visualization.dataSource` = `connectedTable`.
+
+**How to Find Widget IDs**:
+1. Use `cplace_get_layout_overview` to retrieve the page or type layout
+2. Look for widgets in the layout with table-type widget kinds (e.g., `cf.platform.embeddedSearchAsTable`)
+
+**Workflow**: When connecting to a table widget:
+1. Ensure both widgets are on the same page layout
+2. Configure the table widget first (if creating new layout)
+3. Get its `widgetId` from the layout

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

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.visualizations.scriptingLineChart",
+  "Description": "{\"de\":\"Ermöglicht die Konfiguration eines Liniendiagramms mittels cplaceJS.\",\"en\":\"Enables configuration of a line chart using cplaceJS.\"}",
+  "Localized Name": "{\"en\":\"cplaceJS based Line Chart\",\"de\":\"cplaceJS Liniendiagramm\"}",
+  "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.scriptingLineChart/_meta.json

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

package/dist/widget-specifications/cf.cplace.visualizations.scriptingLineChart/_overview.md

@@ -0,0 +1,72 @@
+## Overview
+
+The cplaceJS based Line Chart widget enables configuration of a line chart using cplaceJS. It creates custom time-series visualizations by executing JavaScript code to transform page data into chart series. It bridges configuration-based widgets and fully custom implementations, allowing developers to apply business logic, aggregations, and calculations while leveraging the robust Highcharts rendering engine and built-in UI components.
+
+## Use Cases
+
+### When to Use This Widget
+
+- **Custom Data Transformation**: When you need to aggregate, calculate, or transform page data before visualizing it as a line chart
+- **Complex Business Logic**: When chart data requires logic that cannot be expressed through configuration alone
+- **Dynamic Series Generation**: When the number or nature of chart series depends on runtime data
+- **Advanced Calculations**: When computing trends, moving averages, or other derived metrics
+- **Multi-Source Data**: When combining data from multiple page types or attributes into a single visualization
+
+### Example Scenarios
+
+- Project timeline visualization showing milestone progress over time
+- Resource utilization tracking across multiple projects
+- Performance metrics dashboards with computed KPIs
+- Budget burn-down charts with custom calculation logic
+- Status change trend analysis over time
+
+### When NOT to Use This Widget
+
+- **Simple Attribute Visualization**: Use the Tuple Line Chart widget (`cf.cplace.visualizations.tupleLineChart`) if you only need to display attribute values from tuple data without transformation
+- **No Scripting Requirement**: Prefer configuration-based widgets when they meet your needs for better maintainability
+- **Limited JavaScript Knowledge**: This widget requires cplaceJS expertise
+
+## Design Considerations
+
+### Script-Based Architecture
+
+The widget executes custom cplaceJS code server-side to generate chart series data. Scripts receive:
+- `pages`: Iterable of pages from the configured search results
+- `messages`: Message provider for internationalization support
+
+Scripts must return data in Highcharts series format, with each series containing an ID, name, and array of timestamp-value pairs.
+
+### Timeframe Filtering
+
+The widget includes built-in timeframe filtering capabilities:
+- Client-side filtering by timeframe (all, 3, 6, or 12 months)
+- Scripts should include all data; frontend handles timeframe selection
+- Timeframe selector buttons can be shown or hidden via configuration
+
+### Performance Implications
+
+- Scripts execute server-side on each widget load
+- Performance monitoring is enabled for detailed logging
+- Optimize scripts when processing large datasets
+- Consider data volume when designing search queries
+
+## Common Pitfalls
+
+- **Incorrect Series Format**: Scripts must return a JSONArray in Highcharts format with proper timestamp-value pairs
+- **Missing Series IDs**: Each series needs a unique ID for proper rendering
+- **Unsorted Data**: Pre-sort data points by timestamp for optimal chart performance
+- **Script Errors**: Thoroughly test scripts with various data scenarios as exceptions will display as widget errors
+- **Date Format**: Use timestamps in milliseconds since epoch for x-axis data points
+
+## Alternatives to Consider
+
+| Widget | When to Choose |
+|--------|----------------|
+| **Tuple Line Chart** (`cf.cplace.visualizations.tupleLineChart`) | Simple visualization of tuple attributes without transformation |
+| **cplaceJS based Highcharts** (`cf.cplace.visualizations.scriptingHighcharts`) | Need full control over any Highcharts chart type, not just line charts |
+
+## Related Patterns
+
+- **Master-Detail with Charts**: Use a table widget as master to filter which pages are visualized in the line chart
+- **Dashboard KPI Display**: Combine with other visualization widgets for comprehensive dashboards
+- **Time-Based Trend Analysis**: Pair with search filters to analyze trends across different time periods

package/dist/widget-specifications/cf.cplace.visualizations.scriptingLineChart/_summary.md

@@ -0,0 +1 @@
+Enables configuration of a line chart using cplaceJS. Use for time-series visualizations requiring custom data aggregation, calculations, or business logic that cannot be achieved through configuration-based widgets.

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

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.visualizations.tupleLineChart",
+  "Description": "{\"de\":\"Ermöglicht die Darstellung von Werten eines Tupel-Attributs im zeitlichen Verlauf.\",\"en\":\"Enables the display of values of a tuple attribute over time.\"}",
+  "Localized Name": "{\"en\":\"Tuple Line Chart\",\"de\":\"Tupel-Liniendiagramm\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.visualizations",
+  "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.tupleLineChart/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "chart",
+    "time-series",
+    "references",
+    "read-only",
+    "searchable",
+    "dashboard"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.cplace.visualizations.tupleLineChart/_overview.md

@@ -0,0 +1,50 @@
+## Overview
+
+The Tuple Line Chart widget enables the display of values of a tuple attribute over time. It visualizes time-series data stored in tuple entities by displaying numeric or enumeration values over time. It extracts data from tuple references attached to pages and plots them as line series, making it ideal for monitoring trends, progressions, and changes in associated tuple data.
+
+This widget works specifically with cplace's tuple concept - lightweight data structures representing collections of related attribute values. Each tuple contains a date attribute (for temporal positioning) and one or more value attributes (numeric or enumeration).
+
+## Use Cases
+
+- **Tracking numeric values over time**: Monitor quantitative measurements that change over time (e.g., kilometrage readings, performance metrics, budget consumption)
+- **Monitoring status changes**: Track categorical states over time using enumeration values with optional icons (e.g., inspection status history, approval states)
+- **Comparing multiple metrics**: Display multiple related measurements from the same tuple simultaneously (e.g., actual vs. projected values)
+- **Cross-entity comparison**: Use search mode to compare the same metrics across multiple entities on a dashboard
+
+## Operating Modes
+
+### Embedded Mode (Single Page)
+When embedded directly on a page without a search query, the widget displays tuple data from that specific page only. Multiple value attributes create separate series on the same chart. Use this for detail pages showing historical data for one entity.
+
+### Search Mode (Multiple Pages)
+When configured with a search query, the widget finds multiple pages and creates separate series for each. If multiple value attributes are selected, series names combine page name with attribute name. Use this for dashboards comparing data across multiple entities.
+
+## Design Considerations
+
+### When to Use Tuple Line Chart
+- Data is stored in tuple entities (marked with `.asTuple()`)
+- You need to visualize temporal progressions from tuple collections
+- Values are either all numeric or all enumeration (not mixed)
+
+### When to Use Base Line Chart Instead
+- Data comes from regular page attributes, not tuples
+- You need more flexibility in data source configuration
+- Time-series data is not stored in tuple structures
+
+### Prerequisites
+1. A custom type must be defined as a tuple
+2. The tuple type must have at least one date attribute and one numeric or enumeration attribute
+3. A main entity type must have a multi-reference attribute pointing to the tuple type
+4. Tuple instances must exist and be referenced by pages
+
+## Common Pitfalls
+
+- Selecting value attributes of mixed types (some numeric, some enumeration) - all must be the same type
+- Using enumeration attributes with different element sets - all enum attributes must share identical elements
+- Configuring a tuple attribute that references multiple tuple types - exactly one tuple type is required
+
+## Related Patterns
+
+- **Base Line Chart** (`cf.cplace.visualizations.scriptingLineChart`) - Generic line chart for non-tuple data sources
+- **Tuples Widget** (`cf.cplace.tuplesWidget.widget`) - Table-based display for editing tuple data
+- **Connected Bar Chart** (`cf.platform.connectedBarChart`) - Alternative visualization for categorical comparisons

package/dist/widget-specifications/cf.cplace.visualizations.tupleLineChart/_summary.md

@@ -0,0 +1 @@
+Enables the display of values of a tuple attribute over time. Visualizes time-series data from tuple entities as a line chart, plotting date and numeric or enumeration values for tracking trends and progressions.

package/dist/widget-specifications/cf.platform.attributeHistory/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.attributeHistory",
+  "Description": "{\"en\":\"Shows the change history of an attribute.\",\"de\":\"Zeigt die Änderungshistorie eines Attributs.\"}",
+  "Localized Name": "{\"en\":\"Attribute Versions\",\"de\":\"Attribut-Versionen\"}",
+  "Icon": "fa-undo",
+  "Plugin": "cf.cplace.platform",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details</strong></p>\n\n<p>The 'Attribute Versions' widget shows the version history of an individual attribute in a tabular form.</p>\n\n<p>// This widget is a nested widget.</p>\n\n<p>To configure the 'Attribute Version' widget the following information has to be provided:</p>\n\n<p><strong>Settings</strong></p>\n\n<p>// * Title: Bilingual text. Widget Title.<br>\n// * Page: cplace page. The page that contains the attribute of which you want to display the version history. If you do not specify a page, the current page will be set automatically.<br>\n// * Attribute name*: The custom attribute of which you want to display the version history.<br>\n// * Show editor*: True/false. Detemines if the name of the user who made the edit should be displayed.<br>\n// * Default filter*: Determines if all changes should be displayed or if one of the default filters 'Today', 'Last week', 'Last month', or 'Last years' should be set.<br>\n// * Show filter button*: True/false. Determines if a filter button should be displayed on top of the results.</p>\n\n<p><strong>Key benefits</strong></p>\n\n<p>&nbsp;</p>\n\n<p><strong>Examples</strong></p>"
+}

package/dist/widget-specifications/cf.platform.attributeHistory/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "attributes",
+    "table",
+    "metadata",
+    "read-only",
+    "detail-view",
+    "collaboration"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.platform.attributeHistory/_overview.md

@@ -0,0 +1,79 @@
+## Overview
+
+The Attribute Versions widget shows the change history of an attribute. It tracks and visualizes how a specific attribute's value has evolved over time, displaying a chronological table showing what changed, when it changed, and who made each change. The widget is essential for maintaining audit trails, troubleshooting issues, and providing transparency into data evolution.
+
+The widget retrieves all edit ChangeSets associated with the entity that contain changes to the specified attribute, including the initial value set when the entity was first created. It can display up to 100 historical changes with optional time-range filtering.
+
+## Use Cases
+
+### Audit Trail and Compliance
+Track who changed critical attribute values and when. Maintain compliance records for regulated industries and provide evidence for audits in quality management, financial compliance, or other regulated contexts.
+
+### Troubleshooting and Root Cause Analysis
+Investigate when a value was changed that led to an issue. Identify who made a problematic change and understand the sequence of changes leading to the current state.
+
+### Progress Tracking
+Monitor how status fields evolved over time, track progression through workflow stages, and observe trend changes in numeric or date fields. Useful for understanding project lifecycles and work item evolution.
+
+### Collaboration and Transparency
+Show team members the evolution of shared data and provide visibility into who contributed what changes. Build trust through transparent change tracking.
+
+### Data Recovery Insights
+See previous values that might need to be restored, understand what was lost if incorrect changes were made, and reference historical values for reporting purposes.
+
+## Common Scenarios
+
+- **Project Status Tracking**: Display how a project's status field changed from "Planning" to "In Progress" to "On Hold" to "Completed"
+- **Budget Evolution**: Show how a budget amount was adjusted over time by different team members
+- **Priority Changes**: Track when and by whom a task's priority was escalated
+- **Assignment History**: See who was assigned to a work item over time
+- **Risk Level Monitoring**: Track changes to risk assessment values
+
+## Design Considerations
+
+### Single Attribute Focus
+The widget displays history for one attribute only. To track multiple attributes, use multiple widget instances on the same page. This focused approach keeps the display simple and reduces cognitive load.
+
+### Version Compatibility
+The widget handles version history from different cplace versions gracefully. For older ChangeSets that didn't store new values (pre-5.11), the widget derives missing values from later changes and indicates this with a question mark icon.
+
+### Time Range Filtering
+Use the optional filter button to allow users to dynamically switch between viewing all changes or filtering to recent periods (today, last week, last month, last year). The default filter sets the initial view when the page loads.
+
+### Display Limits
+The widget displays a maximum of 100 history items. For attributes with extensive change history, this limit ensures reasonable performance. A placeholder row indicates when older changes exist beyond the current filter.
+
+### Editor Visibility
+Choose whether to show the "Editor" column based on your needs. Enable it for accountability and collaboration contexts, disable it for cleaner displays when the change author is less relevant.
+
+## Constraints and Limitations
+
+### Non-Derived Attributes Only
+The widget only tracks attributes that store actual values, not computed or derived properties. Derived attributes don't have stored change history.
+
+### CustomEntity Only
+The widget works exclusively with custom entities (pages with custom types). It cannot track built-in system entity attributes.
+
+### Edit ChangeSets Only
+Only changes from edit operations are included. The initial value is shown, but other ChangeSet types (deletion, etc.) are not included in the attribute-specific tracking.
+
+### No Access Control Filtering
+All historical changes are visible regardless of current user permissions. This ensures complete audit trail visibility but means sensitive historical changes remain visible even if editor permissions have changed.
+
+### No Export Functionality
+The widget displays data in-page only with no built-in CSV or Excel export capability. For exportable history, consider alternative approaches or custom development.
+
+## Related Widgets
+
+### Version Info Widget (`cf.platform.modificationInfo`)
+Shows overall entity modification metadata (created/modified dates and users). Use together with Attribute Versions for a complete audit trail - Version Info provides the high-level timeline while Attribute Versions provides attribute-specific detail.
+
+### Comments Widget (`cf.platform.comments`)
+Provides manual annotations about changes. Use together with Attribute Versions to combine automatic data change tracking with human explanations and context.
+
+### Attributes Widget (`cf.platform.attributes`)
+Displays current attribute values. Use on the same page to show both current state (Attributes) and historical evolution (Attribute Versions).
+
+## Technical Context
+
+The widget is part of the platform's versioning and audit trail capabilities, built on top of the ChangeSet system. It provides user-facing visibility into the versioning backend, complementing system-wide version tracking with attribute-specific detail.

package/dist/widget-specifications/cf.platform.attributeHistory/_summary.md

@@ -0,0 +1 @@
+Shows the change history of an attribute, displaying old values, new values, timestamps, and editors in a chronological table format.

package/dist/widget-specifications/cf.platform.attributes/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.attributes",
+  "Description": "{\"en\":\"Shows all attributes of a page and allows you to edit them.\",\"de\":\"Zeigt alle Attribute einer Seite und erlaubt ihre Bearbeitung.\"}",
+  "Localized Name": "{\"en\":\"Attributes\",\"de\":\"Attribute\"}",
+  "Icon": "fa-pen-square",
+  "Plugin": "cf.cplace.platform",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details</strong></p>\n\n<p>The 'Attributes' widget displays all attributes of the page on which it is added and allows you to edit their values.</p>\n\n<p><strong>Key benefits</strong></p>\n\n<p>&nbsp;</p>\n\n<p><strong>Examples</strong></p>"
+}

package/dist/widget-specifications/cf.platform.attributes/_meta.json

@@ -0,0 +1,9 @@
+{
+  "tags": [
+    "attributes",
+    "form",
+    "detail-view",
+    "inline-edit"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.platform.attributes/_overview.md

@@ -0,0 +1,89 @@
+## Overview
+
+The Attributes widget shows all attributes of a page and allows you to edit them. It provides a comprehensive view of all attributes defined on a page's type, automatically discovering and displaying every attribute without requiring manual selection or layout configuration. This "convention over configuration" approach makes it the simplest way to show complete attribute information on any entity page.
+
+The widget displays attributes in the order defined in the type definition and includes custom attributes, built-in system attributes, and inherited attributes from parent types.
+
+Shows ALL attributes automatically with no control. **Use only for rapid prototyping, never for production layouts.**
+
+
+## Use Cases
+
+### Standard Page Attribute Display
+
+Display all attributes on entity detail pages where complete attribute coverage is needed. This is common for:
+
+- Entity detail pages where all information should be visible
+- Admin or configuration pages showing complete data
+- Forms where all attributes need to be filled out
+
+### Rapid Prototyping
+
+Build pages quickly without manually configuring individual attribute widgets. The widget automatically adapts when type definitions change, making it ideal for:
+
+- Early development phases
+- Proof-of-concept implementations
+- Internal tools where UI polish is secondary
+
+### Settings and Configuration Pages
+
+Display all configuration options for system settings pages, entity configuration forms, or type definition pages showing available attributes.
+
+### Full Edit Forms
+
+Provide complete editable forms for entities when users need to edit multiple attributes at once, such as bulk data entry scenarios or entity creation workflows.
+
+## Design Considerations
+
+### Zero Configuration Philosophy
+
+The widget intentionally has no user-configurable parameters. This design choice prioritizes:
+
+- Immediate functionality without setup
+- Automatic adaptation to type definition changes
+- Consistent presentation across all entity types
+
+### Permission-Aware Rendering
+
+The widget respects entity-level permissions:
+
+- Read permission is required to view the widget
+- Edit permission is required to see the "Edit" button
+- Individual attributes may have additional read/write restrictions
+
+### Attribute Filtering
+
+By default, the widget excludes attributes marked as "hidden in attributes widget" in the type definition. The order of attributes matches the type definition order.
+
+## Alternatives
+
+Consider these alternatives when the Attributes widget does not meet your requirements:
+
+| Requirement | Recommended Alternative |
+|-------------|------------------------|
+| Custom layout with columns or grouping | Grouped Attributes of a Page (`cf.cplace.platform.attributesGroup`) |
+
+### Decision Guide
+
+**Use the Attributes widget when**:
+- You need to show all attributes of a page
+- Zero configuration setup is preferred
+- Default ordering and layout is acceptable
+- Building internal tools or prototypes quickly
+
+**Consider alternatives when**:
+- Custom attribute layout is required
+- Only specific attributes should be visible
+- Attributes need custom labels or conditional visibility
+- Integration with table selections is needed
+
+## Embedding Constraints
+
+The widget can be embedded on:
+- CustomEntity pages (standard entity pages with type definitions)
+- Type definition pages
+
+The widget cannot be embedded in:
+- Spaces (workspace-level pages)
+- Documents (file entities)
+- Other widgets (it is not container-embeddable)

package/dist/widget-specifications/cf.platform.attributes/_summary.md

@@ -0,0 +1 @@
+Shows all attributes of a page and allows you to edit them. Automatically renders all defined attributes according to the page's type definition without requiring manual configuration. Shows ALL attributes automatically with no control. Use only for rapid prototyping, never for production layouts.

package/dist/widget-specifications/cf.platform.comments/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.comments",
+  "Description": "{\"en\":\"Enables comments to be added to a page.\",\"de\":\"Ermöglicht das Hinzufügen von Kommentaren zu einer Seite.\"}",
+  "Localized Name": "{\"en\":\"Comments\",\"de\":\"Kommentare\"}",
+  "Icon": "fa-comments",
+  "Plugin": "cf.cplace.platform",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details</strong></p>\n\n<p>The 'Comments' widget allows users to add comments to a cplace page.</p>\n\n<p><strong>Settings</strong></p>\n\n<p>// * Widget title: Bilingual text.</p>\n\n<p>// * Fixed height:</p>\n\n<p>&nbsp;</p>"
+}

package/dist/widget-specifications/cf.platform.comments/_meta.json

@@ -0,0 +1,9 @@
+{
+  "tags": [
+    "comments",
+    "collaboration",
+    "inline-edit",
+    "detail-view"
+  ],
+  "requiredApp": null
+}