@cplace/mcp-server 1.3.14

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

@@ -0,0 +1,69 @@
+## Overview
+
+Displays a single attribute of a selected table entry dynamically. Prerequisite: There must be a table widget on the page.
+
+The Connected Single Attribute Widget displays a single attribute value from an entity that is dynamically selected in a connected table or selection widget. Unlike the standard Single Attribute Widget which displays attributes from a fixed entity, this widget updates automatically when users select different rows in a connected table.
+
+This widget implements the master-detail pattern by showing specific attribute values from entities selected in related table widgets, making it ideal for building interactive detail panels, quick edit interfaces, and responsive data exploration experiences.
+
+## Use Cases
+
+### Master-Detail View
+Display detailed information about a selected table row. A table lists projects, and connected single attribute widgets show the selected project's status, owner, budget, and description in a detail panel. When users click different rows, all connected widgets update simultaneously.
+
+### Quick Edit Interface
+Allow inline editing of specific attributes from a selection. A table of tasks where selecting a task allows quick status updates via connected single attribute widgets with in-place editing enabled. Changes can trigger automatic reload of dependent widgets.
+
+### Conditional Attribute Display
+Show different attributes based on the selected entity's state. Display "Approval Date" only for approved items, or "Rejection Reason" only for rejected items using cplaceJS scripts for conditional visibility.
+
+### Grouped Attributes Display
+Multiple related attributes displayed together with a shared table selection. Embed multiple connected single attribute widgets within a Connected Attributes Group Widget to create a form-like interface showing multiple attributes from the selected entity.
+
+### Inline Display in Rich Text
+Embed dynamic attribute values within narrative content. A report page with text like "The selected project's current status is [status widget] and is owned by [owner widget]."
+
+## Design Considerations
+
+### Connected Widget Requirement
+This widget requires a connection to a widget that produces single entity selections (implements `ISingleEntitySelectionProducer`). The most common source is the Embedded Search as Table widget. The widget starts with no target entity and updates based on user selections.
+
+### Display Modes
+The widget supports flexible display configurations:
+- **Value only**: Displays just the attribute value, useful for inline embedding in sentences
+- **Label only**: Shows only the attribute label, useful for headers or dynamic labels
+- **Label and value**: Standard form field appearance with both elements
+- **Stacked layout**: Label displayed above value, better for narrow layouts
+
+### Embedding Contexts
+The widget can be embedded in two contexts:
+1. **Rich text content**: Directly in page content for inline displays
+2. **Connected Attributes Group Widget**: For structured form-like interfaces where the parent widget manages the table connection
+
+When embedded in a Connected Attributes Group, the parent widget controls the table selection for all embedded widgets, and its layout settings can override individual widget settings.
+
+### In-Place Editing
+When editing is enabled, users can modify attribute values directly without leaving the page. Consider enabling the reload-after-change option to refresh dependent widgets when values change.
+
+### Conditional Visibility
+The widget supports cplaceJS scripts that evaluate the current selection to determine whether the attribute should be displayed. This enables dynamic interfaces that adapt to the selected entity's state.
+
+## Common Pitfalls
+
+- Forgetting to specify the connected selection widget ID
+- Not enabling at least one display option (value or label)
+- Using this widget when a static Single Attribute Widget would suffice (no dynamic selection needed)
+- Not considering the reload behavior after edits when other widgets depend on the edited values
+
+## Alternatives to Consider
+
+| Widget | When to Use Instead |
+|--------|---------------------|
+| **Single Attribute Widget** (`cf.platform.singleAttribute`) | When the entity is fixed and known at design time, not based on user selection |
+| **Connected Attributes Group Widget** (`cf.cplace.platform.connectedAttributesGroup`) | When displaying multiple attributes together with shared table selection - use this as a container with embedded connected single attribute widgets |
+
+## Related Patterns
+
+- **Master-Detail Pattern**: Use with a table widget as the master and multiple connected single attribute widgets as the detail display
+- **Quick Edit Interface**: Combine with in-place editing for efficient data updates from table selections
+- **Dashboard Panels**: Create KPI displays based on filtered table selections using connected single attributes

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

@@ -0,0 +1 @@
+Displays a single attribute of a selected table entry dynamically. Prerequisite: There must be a table widget on the page. Use for master-detail views, quick edit interfaces, and detail panels that respond to table row selections.

package/dist/widget-specifications/cf.platform.connectedSingleAttribute/attributeName.md

@@ -0,0 +1,10 @@
+**Warning**: Use the full internal attribute name, not the simple/short name!
+
+**Important**:
+- **Custom attributes** require single quotes around the attribute name: `'cf.cplace.myApp.myAttribute'`
+- **Builtin attributes** (e.g., `name`, `createdAt`, `creator`, `modifiedAt`, `modifier`, `owner`) are specified without quotes: `name`
+
+**Workflow**:
+1. Call `cplace_get_type_datamodel` for the type displayed in the connected table
+2. Find the custom attribute you want to display
+3. Use the custom attribute's `name` field (the full internal name), wrapped in single quotes

package/dist/widget-specifications/cf.platform.connectedSingleAttribute/singleColumn.md

@@ -0,0 +1,9 @@
+**Note**: This attribute is only relevant when both `withValue=true` AND `withLabel=true`.
+
+**Layout Modes**:
+- `false` (default): Two-column layout with label and value side by side
+- `true`: Single-column layout with label above value
+
+**Parent Widget Override**: When this widget is embedded inside a `cf.platform.connectedAttributesGroup` widget, the parent widget's `singleColumn` setting takes precedence over this widget's setting. The parent's layout configuration will override the individual widget's setting.
+
+**Example**: If the parent ConnectedAttributesGroup has `singleColumn=true`, all embedded ConnectedSingleAttribute widgets will use single-column layout regardless of their individual `singleColumn` settings.

package/dist/widget-specifications/cf.platform.connectedSingleAttribute/singleSelectionWidgetId.md

@@ -0,0 +1,3 @@
+**Valid Values**:
+- When embedded inside a `cf.cplace.platform.connectedAttributesGroup` widget, use `"<empty>"` as the value - the parent widget provides the actual table connection
+- When the connection goes against a `cf.platform.treeTable` widget - insert the widget ID

package/dist/widget-specifications/cf.platform.connectedSingleAttribute/withLabel.md

@@ -0,0 +1,11 @@
+**Warning**: At least one of `withValue` or `withLabel` must be `true` for the widget configuration to be complete!
+
+**Valid Values**:
+- `false` (default): Hide the attribute's label/name
+- `true`: Show the attribute's localized label/name
+
+**Configuration Completeness Check**: The widget validates that at least one display option is enabled. If both `withValue=false` and `withLabel=false`, the configuration is considered incomplete and the widget will not render properly.
+
+**Note**: The `singleColumn` attribute is only relevant when `withLabel=true` and `withValue=true` - it controls whether the label and value are displayed side by side or stacked vertically.
+
+**Frontend Behavior**: When `withLabel=false` and `inPlaceEditing=false`, the widget renders in inline mode using a span element. Otherwise, it uses a block-level div element.

package/dist/widget-specifications/cf.platform.connectedSingleAttribute/withValue.md

@@ -0,0 +1,12 @@
+**Warning**: At least one of `withValue` or `withLabel` must be `true` for the widget configuration to be complete!
+
+**Valid Values**:
+- `true` (default): Show the attribute's value
+- `false`: Hide the attribute's value (only valid if `withLabel=true`)
+
+**Configuration Completeness Check**: The widget validates that at least one display option is enabled. If both `withValue=false` and `withLabel=false`, the configuration is considered incomplete and the widget will not render properly.
+
+**Common Patterns**:
+- `withValue=true, withLabel=false`: Display value only (inline mode)
+- `withValue=true, withLabel=true`: Display both label and value
+- `withValue=false, withLabel=true`: Display label only (useful for showing which attribute is selected without showing its value)

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

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.connectedTableFilter",
+  "Description": "{\"en\":\"Displays the column filters of a table and enables you to adjust the filter criteria.\",\"de\":\"Zeigt die Spaltenfilter einer Tabelle an und ermöglicht die Anpassung der Filterkriterien.\"}",
+  "Localized Name": "{\"en\":\"Filter Configuration of a Table\",\"de\":\"Filterkonfiguration einer Tabelle\"}",
+  "Icon": "fa-filter",
+  "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 'Filter Criteria of a Table' widget shows the current column filters of a table and allows you to modify the filter criteria.</p>\n\n<p><strong>Prerequisites</strong></p>\n\n<p>A table must be embedded in the page.</p>\n\n<p><strong>Settings</strong></p>\n\n<p>// * Table*:</p>"
+}

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

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "filterable",
+    "connected",
+    "table",
+    "dashboard",
+    "navigation"
+  ],
+  "requiredApp": null
+}

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

@@ -0,0 +1,89 @@
+## Overview
+
+Displays the column filters of a table and enables you to adjust the filter criteria.
+
+The Filter Configuration widget provides users with an interactive interface to view and modify the active column filters of a connected table widget. Instead of filtering directly within a table header, this widget exposes filter controls as a separate, dedicated component that can be positioned anywhere on the layout. This separation enables cleaner table interfaces while providing prominent, easy-to-access filter controls.
+
+The widget displays all filterable columns from the connected table and shows their current filter states. Users can modify filter criteria through the widget, and changes are immediately reflected in the connected table's displayed data.
+
+## Use Cases
+
+### Dashboard Layouts with Prominent Filter Controls
+- Displaying filter controls above or beside table widgets on dashboards
+- Creating filter panels that remain visible while scrolling through large tables
+- Providing dedicated space for complex filtering interfaces without cluttering table headers
+- Building analytical dashboards where filter configuration is a primary user task
+
+### Master-Detail Patterns with Shared Filtering
+- Allowing users to adjust filters while viewing detail views
+- Creating side-by-side layouts with filter controls and filtered results
+- Enabling filter manipulation without returning to the table view
+- Supporting workflows where filter criteria need frequent adjustment
+
+### Guided Filtering Workflows
+- Presenting filter options in a specific order or grouping
+- Creating step-by-step data exploration interfaces
+- Building filtering experiences that guide users through available filter dimensions
+- Implementing progressive disclosure of filtering capabilities
+
+## Operating Mode
+
+### Connected Table Mode
+The widget requires a connection to a table widget via the `tableWidgetId` attribute. Once connected, the filter widget:
+- Automatically discovers all filterable columns from the connected table
+- Displays the current filter state for each column
+- Synchronizes filter changes bidirectionally with the table
+- Updates when the table's filter configuration changes
+
+The connected table must be one of these compatible widget types:
+- `cf.platform.embeddedSearchAsTable`
+- `cf.cplace.platform.tableWidget`
+- Other table widgets that support column filtering
+
+## Design Considerations
+
+### When to Use This Widget
+Choose this widget when:
+- You want to separate filter controls from the table header for cleaner table interfaces
+- Filter controls need prominent positioning (e.g., dashboard headers, side panels)
+- You're building workflows where filtering is a primary user interaction
+- You need filter controls to remain visible while scrolling through table data
+- You want to provide a dedicated space for filter guidance or instructions
+
+### When NOT to Use This Widget
+Avoid this widget when:
+- Simple in-table filtering is sufficient for your use case
+- You don't need filter controls to be separate from the table
+- The table has few or no filterable columns
+- Screen space is limited and you can't afford separate filter UI
+
+### Connection Requirements
+The widget requires:
+- A table widget on the same layout/page
+- The table widget must support column filtering
+- The table widget's ID must be known for configuration
+- Both widgets must be visible to the user for proper interaction
+
+### User Experience Considerations
+- The filter widget provides no visual indication of the connected table - consider adding explanatory text or positioning the widgets adjacently
+- Filter changes take effect immediately, which is intuitive but requires the table to be visible for users to see the impact
+- Users need appropriate permissions to both view and modify filters on the underlying data
+
+## Common Pitfalls
+
+- **Missing table connection**: The widget is non-functional without a valid `tableWidgetId` reference. Always verify the table widget ID during configuration.
+- **Non-filterable columns**: If the connected table has no filterable columns configured, the filter widget will appear empty. Ensure the table has filterable columns enabled.
+- **Hidden table widget**: If the connected table is not visible on the same layout (e.g., on a different tab), filter changes may confuse users who cannot see the results update.
+- **Permission mismatches**: Users need permissions to filter the data in the connected table. If permissions are insufficient, the filter widget may appear but not function correctly.
+
+## Alternative Widgets
+
+- **Native table filtering**: Use the table widget's built-in column filters when a separate filter UI is not needed
+- **cf.cplace.platform.tableWidget**: Consider this table widget which includes comprehensive built-in filtering capabilities in the table header
+- **cf.platform.embeddedSearchAsTable**: This table widget also provides native column filtering that may be sufficient without a separate filter widget
+
+## Related Patterns
+
+- **Master-Detail Pattern**: Combine with table widgets and detail view widgets to create comprehensive data exploration interfaces
+- **Dashboard Layouts**: Position filter widgets prominently in dashboard headers or side panels for analytical workflows
+- **Progressive Disclosure**: Use filter widgets to guide users through multi-step filtering processes with clear, dedicated UI space

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

@@ -0,0 +1 @@
+Displays the column filters of a table and enables you to adjust the filter criteria. Use in dashboard layouts and master-detail patterns to provide prominent, dedicated filter controls alongside table displays.

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

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.customRichStringAttribute",
+  "Description": "{\"de\":\"Zeigt den Inhalt eines Rich-String-Attributs und erlaubt es, diesen über einen WYSIWYG-Editor zu bearbeiten.\",\"en\":\"Shows the content of a Rich String attribute and enables you to edit this content using a WYSIWYG editor.\"}",
+  "Localized Name": "{\"en\":\"Richstring Attribute\",\"de\":\"Attribut mit formatiertem Text\"}",
+  "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 'Richstring Attribute' widget displays the value of an attribute of type 'Richtstring'. You can specify whether the widget should be surrounded by a frame or not.</p>\n\n<p>&nbsp;</p>\n\n<p>&nbsp;</p>"
+}

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

@@ -0,0 +1,9 @@
+{
+  "tags": [
+    "rich-text",
+    "attributes",
+    "detail-view",
+    "read-only"
+  ],
+  "requiredApp": null
+}

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

@@ -0,0 +1,39 @@
+## Overview
+
+Shows the content of a Rich String attribute and enables you to edit this content using a WYSIWYG editor.
+
+The Custom Rich String Attribute widget renders formatted text content stored in RichString attributes of custom entities. It displays the attribute value with all HTML formatting intact, including bold, italic, lists, links, headings, and other rich text elements.
+
+The widget offers two display modes: framed (with a visible border and the attribute's localized name as the title) or frameless (for seamless content integration into the page layout).
+
+## Use Cases
+
+- **Formatted descriptions** - Display project descriptions, requirement documentation, or detailed explanations with preserved formatting
+- **Rich text notes** - Show user-entered notes that include styling like lists, links, and emphasis
+- **Content sections** - Present detailed information that benefits from headings, bullet points, and structured formatting
+- **Inline documentation** - Embed formatted explanatory text within page layouts
+
+## Design Considerations
+
+### When to Use
+
+- The attribute contains formatted text that loses meaning without its formatting
+- You want to display a single RichString attribute prominently
+- The content should be read-only (no direct editing from the widget)
+
+### Frame vs Frameless
+
+- **With frame** (`showFrame: true`): Creates visual separation, displays the attribute's localized name as a title. Best when the content is a distinct section.
+- **Frameless** (`showFrame: false`): Content integrates seamlessly into the page. Best for inline content where visual boundaries are unwanted.
+
+### Limitations
+
+- Only works with attributes that have a RichString constraint
+- Must be embedded within a custom entity context
+- Read-only display; does not support inline editing
+
+## Related Patterns
+
+- **Single Attribute Widget** (`cf.platform.singleAttribute`) - More generic widget for various attribute types; consider when you need to display non-rich-text attributes or want editing capabilities
+- **Connected Single Attribute Widget** (`cf.platform.connectedSingleAttribute`) - Use when the attribute value should come from a table selection rather than the embedding entity
+- **Attributes Widget** (`cf.platform.attributes`) - Use when you need to display multiple attributes together in a group

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

@@ -0,0 +1 @@
+Shows the content of a Rich String attribute and enables you to edit this content using a WYSIWYG editor. Provides optional frame display for visual separation or seamless frameless integration.

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

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.embeddedSearchAsList",
+  "Description": "{\"en\":\"Generates a list of search results sorted alphabetically.\",\"de\":\"Erzeugt eine alphabetisch sortierte Liste aus Suchresultaten.\"}",
+  "Localized Name": "{\"en\":\"List\",\"de\":\"Liste\"}",
+  "Icon": "fa-list-alt",
+  "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 'List' widget displays an alphabetically sorted list generated from search results.</p>\n\n<p><strong>Settings</strong></p>\n\n<p>// * Search*:</p>\n\n<p>// * Title: Bilingual text.</p>\n\n<p>// * Sort criterion:</p>\n\n<p>// * Sort order: Ascending/descending.</p>\n\n<p>// * Height:</p>\n\n<p>&nbsp;</p>"
+}

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

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "list",
+    "searchable",
+    "read-only",
+    "navigation",
+    "references"
+  ],
+  "requiredApp": null
+}

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

@@ -0,0 +1,66 @@
+## Overview
+
+Generates a list of search results sorted alphabetically.
+
+The Embedded Search as List widget executes a configured search query and displays the results as a simple unordered list of clickable page links. It provides a lightweight alternative to table-based widgets when you only need to show page names without additional columns or complex formatting.
+
+The widget automatically sorts results alphabetically when no custom sort is specified and no full-text search is used. Full-text searches use relevance scoring by default.
+
+## Use Cases
+
+### Navigation Lists
+- Quick navigation menus based on dynamic queries
+- Recently modified pages
+- Favorited or tagged items
+- Pages within a specific workspace
+
+### Related Content Display
+- Child pages of the current page
+- Related documents or tasks
+- Team members or stakeholders
+- Items in a specific category
+
+### Embedded Dynamic Content
+- Include dynamic lists within documentation
+- Show related references in description fields
+- Embed contextual search results in rich text content
+
+### Lightweight Result Display
+- When only page names and links are needed
+- Mobile-friendly simple lists
+- Filtered content views by status, category, or type
+
+## Design Considerations
+
+### Result Limitations
+The widget displays up to 1000 results. When results exceed this limit, an informational message indicates that only the first 1000 results are shown. For larger datasets requiring pagination, consider the table widget instead.
+
+### Sorting Behavior
+- Custom sort column and order can be configured
+- Without custom sort and without text search: alphabetical sorting applied
+- With text search: relevance-based sorting preserved
+
+### Empty State Handling
+When the search returns no results, a "No results" message is displayed.
+
+## Common Pitfalls
+
+- Using this widget for datasets exceeding 1000 items where users need to see all results
+- Choosing this widget when multiple attributes per result need to be displayed
+- Expecting interactive filtering capabilities (use connected table filter pattern instead)
+
+## Alternatives
+
+| Scenario | Recommended Widget |
+|----------|-------------------|
+| Need column-based data display | `cf.platform.embeddedSearchAsTable` |
+| Need user-controlled filtering | `cf.platform.embeddedSearchAsTable` with `cf.platform.connectedTableFilter` |
+| Need to show backlinks to current page | `cf.platform.incomingReferences` |
+| Large datasets requiring pagination | `cf.platform.embeddedSearchAsTable` |
+| Visual data representation | Chart widgets (pie, bar) |
+
+## Related Patterns
+
+- **Search-based widgets**: Part of a family including table, chart, and matrix variants that share search configuration but differ in presentation
+- **Rich text embedding**: Can be embedded within rich string attributes for inline dynamic content
+- **Master-detail**: Unlike the table widget, this widget does not support selectable items for master-detail patterns

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

@@ -0,0 +1 @@
+Generates a list of search results sorted alphabetically. Ideal for navigation lists, related items, and embedded dynamic content where tabular formatting is unnecessary.

package/dist/widget-specifications/cf.platform.embeddedSearchAsList/search.md

@@ -0,0 +1,8 @@
+**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 the search configuration

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

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.embeddedSearchAsTable",
+  "Description": "{\"en\":\"Generates a table of search results.\",\"de\":\"Erzeugt eine Tabelle aus Suchergebnissen.\"}",
+  "Localized Name": "{\"en\":\"Table\",\"de\":\"Tabelle\"}",
+  "Icon": "fa-table",
+  "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 'Table' widget can be used to display the results of a search in tabular form.</p>\n\n<p><strong>Settings</strong></p>\n\n<p>// * Search*:<br>\n// * Title: Bilingual text.<br>\n// * Columns:<br>\n// * Filters<br>\n// * Connected table:<br>\n// * Single spaced display*:<br>\n// * Show actions*:<br>\n// * Show header*:<br>\n// * Disable links in name column*:<br>\n// * Hide names*:<br>\n// * Sorting<br>\n// * Show \"New\" button*:<br>\n// * Height:</p>\n\n<p><strong>Key Benefits</strong></p>\n\n<p><strong>Examples</strong></p>"
+}

package/dist/widget-specifications/cf.platform.embeddedSearchAsTable/_implementation.md

@@ -0,0 +1,10 @@
+**Configuration Modes**:
+- `search`: Query pages via embedded search (most common)
+  - Requires: `search` attribute with `cplaceJson` value from `cplace_search_pages`
+- `connectedTable`: Display data from another table widget on the page
+  - Requires: `connectedTableWidgetId` pointing to the source widget
+
+**Typical Configuration Workflow**:
+1. Configure either `search` or `connectedTableWidgetId`
+2. Define visible columns via `columns` attribute
+3. Optionally configure sorting (`multiSortColumns`), filtering (`filters`), and grouping (`groupColumn`)

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

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "table",
+    "searchable",
+    "filterable",
+    "sortable",
+    "selectable",
+    "navigation"
+  ],
+  "requiredApp": null
+}

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

@@ -0,0 +1,109 @@
+## Overview
+
+Generates a table of search results.
+
+The Embedded Search Table displays a filtered list of pages in a tabular format. It is the most versatile and commonly used widget for presenting collections of data in cplace.
+
+**Use when you need to:**
+- Show a list of pages matching certain criteria
+- Enable users to browse, sort, and select from a collection
+- Create master-detail interactions between widgets
+- Display related entities on a page detail view
+
+**Alternatives:**
+- **New Table Widget** - Modern alternative with different feature set
+- **Embedded Search as List** - Simpler card-based display without columns
+
+## Operating Modes
+
+### Standalone Mode
+
+The table operates independently, showing results based on its own search criteria. This is the simplest mode—define what pages to show, and the table displays them.
+
+**Typical scenarios:**
+- A list of all active projects in a workspace
+- Showing open tasks assigned to the current user
+- Displaying recent documents matching a category
+
+### Master Mode
+
+The table serves as a selection source for other widgets. When a user selects a row, connected widgets update to show related information.
+
+**Typical scenarios:**
+- Project list where selecting a project updates charts and detail panels
+- Resource list driving a capacity timeline view
+- Category browser controlling what appears in detail tables
+
+### Detail Mode
+
+The table reacts to selections made in another widget. Its contents filter dynamically based on what the user selected elsewhere.
+
+**Typical scenarios:**
+- Showing tasks belonging to a selected project
+- Displaying team members assigned to a selected department
+- Listing documents related to a selected category
+
+### Embedding Context Mode
+
+When placed on a page detail layout, the table can automatically filter to show entities related to that specific page. The table "knows" which page it's embedded on and uses that context.
+
+**Typical scenarios:**
+- On a Project page: showing all tasks belonging to this project
+- On a Person page: showing all assignments for this person
+- On a Category page: showing all items in this category
+
+## Design Considerations
+
+### When to Use Master-Detail
+
+Master-detail patterns work well when:
+- Users need to explore relationships between entities
+- The detail view would be too cluttered without context
+- There's a clear parent-child or one-to-many relationship
+
+Avoid master-detail when:
+- Each table serves an independent purpose
+- Users need to see all information simultaneously
+- The relationship between data sets isn't intuitive
+
+### Scoping to Workspace
+
+Tables should almost always be scoped to the current workspace. This prevents data leakage across workspaces and ensures users only see relevant content. Cross-workspace tables are rare and require explicit justification.
+
+### Showing Multiple Types
+
+A single table can display pages of different types. This is useful for unified views (e.g., "all requests and responses") but requires careful column selection since different types have different attributes. Include a type indicator column so users can distinguish between row types.
+
+### Negation Filters
+
+Sometimes it's easier to define what you *don't* want rather than what you do. Negation filters exclude matching items, which is useful for:
+- Showing "everything except active items" (catches future status values automatically)
+- Excluding specific categories without listing all included ones
+- Creating complementary table pairs (active vs. inactive)
+
+## Connection Patterns
+
+### Driving Charts and Visualizations
+
+Tables can drive chart widgets. When users select rows in the table, charts update to reflect that selection. This creates interactive dashboards where the table serves as a data navigator.
+
+### Cascading Detail Tables
+
+Multiple tables can form a hierarchy: Table A drives Table B, which drives Table C. This enables drill-down exploration through data relationships (e.g., Portfolio → Projects → Tasks).
+
+### Coordinated Height
+
+When tables appear side-by-side in master-detail layouts, matching their heights creates visual harmony and makes the relationship between them clearer.
+
+## Common Pitfalls
+
+- **Missing connection setup** - Detail tables need both the connection reference and the appropriate search filter; one without the other won't work
+- **Overly broad searches** - Forgetting to scope to workspace can surface unexpected data from other contexts
+- **Column mismatch** - Specifying columns that don't exist on the searched type results in empty columns
+- **Inconsistent visual treatment** - Master and detail tables with different heights or density settings look disconnected
+
+## Related Patterns
+
+- **Lifecycle Status Split** - Pair of tables showing active vs. inactive items
+- **Dashboard Context Scoping** - All widgets on a dashboard filtering relative to the dashboard page's attributes
+- **Hierarchical Drill-Down** - Cascading master-detail through multiple levels

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

@@ -0,0 +1 @@
+Generates a table of search results. Use for listing collections of data with support for master-detail interactions, column configuration, and user-driven sorting.

package/dist/widget-specifications/cf.platform.embeddedSearchAsTable/columns.md

@@ -0,0 +1,16 @@
+**Warning**: Every column must reference an attribute that actually exists on the **target type** being displayed in the table. Before configuring columns, use cplace MCP tools to look up the target type's actual attributes and verify that each column attribute name exists. Never assume or reconstruct attribute names. Columns referencing non-existent attributes will fail silently or produce errors.
+
+**JSON Format**:
+```json
+[
+  {"name": "'cf.cplace.myType.attributeName'", "visible": true},
+  {"name": "'cf.cplace.myType.otherAttribute'", "visible": false},
+  {"name": "name", "visible": true}
+]
+```
+
+**Important**:
+- **Custom attributes** require single quotes around the attribute name: `"'cf.cplace.myType.attributeName'"`
+- **Builtin attributes** (e.g., `name`, `createdAt`, `creator`, `modifiedAt`, `modifier`, `owner`) are specified without quotes: `"name"`
+
+**Note**: Order in array determines column display order. Hidden columns (`visible: false`) can still be used for sorting/filtering.

package/dist/widget-specifications/cf.platform.embeddedSearchAsTable/multiSortColumns.md

@@ -0,0 +1,16 @@
+**JSON Format**:
+```json
+[
+  {"sortColumn": "'cf.cplace.myType.attribute1'", "sortOrder": "asc", "sortingPriorityIndex": 1},
+  {"sortColumn": "'cf.cplace.myType.attribute2'", "sortOrder": "desc", "sortingPriorityIndex": 2},
+  {"sortColumn": "name", "sortOrder": "asc", "sortingPriorityIndex": 3}
+]
+```
+
+**Valid sortOrder values**: `"asc"`, `"desc"`
+
+**Important**:
+- **Custom attributes** require single quotes around the attribute name: `"'cf.cplace.myType.attributeName'"`
+- **Builtin attributes** (e.g., `name`, `createdAt`, `creator`, `modifiedAt`, `modifier`, `owner`) are specified without quotes: `"name"`
+
+**Note**: `sortingPriorityIndex` determines which sort applies first (lower = higher priority).

package/dist/widget-specifications/cf.platform.embeddedSearchAsTable/search.md

@@ -0,0 +1,21 @@
+**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 the search configuration
+
+**Relative Filters** (e.g., "show items referencing current page"):
+
+When using `relativeReference` filters, you MUST provide a real page UID as context:
+
+```
+cplace_search_pages(
+  search_filter: [{"relativeReference": {"attribute": "myType.refAttr", "operator": "embeddingCustomEntity"}}],
+  embeddingEntityUid: "page/abc123"  // ← Real page UID required!
+)
+```
+
+Without a concrete `embeddingEntityUid`, the relative filter won't be included in the returned `cplaceJson`.