@cplace/mcp-server 1.3.14

package/dist/widget-specifications/cf.cplace.landingPageFromPage.quickOverview/_summary.md

@@ -0,0 +1 @@
+Shows at a glance results for a defined search with a prominent hit count, configurable title/icon, and a limited list of clickable items.

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

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.landingPageFromPage.sessionUserNameWidget",
+  "Description": "{\"en\":\"Displays the username and a customizable greeting message\",\"de\":\"Zeigt den Nutzernamen und eine anpassbare Grußbotschaft an\"}",
+  "Localized Name": "{\"en\":\"Welcome Message\",\"de\":\"Begrüßungstext\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.landingPageFromPage",
+  "App": "cf.cplace.landingPageFromPage",
+  "Localized App Name": "{\"en\":\"Landing Page from a cplace Page\",\"de\":\"Landing Page aus einer cplace-Seite\"}",
+  "Repository": "cplace-paw",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.landingPageFromPage.sessionUserNameWidget/_meta.json

@@ -0,0 +1,9 @@
+{
+  "tags": [
+    "metadata",
+    "read-only",
+    "dashboard",
+    "detail-view"
+  ],
+  "requiredApp": "cf.cplace.landingPageFromPage"
+}

package/dist/widget-specifications/cf.cplace.landingPageFromPage.sessionUserNameWidget/_overview.md

@@ -0,0 +1,52 @@
+## Overview
+
+Displays the username and a customizable greeting message.
+
+The Welcome Message widget creates a personalized greeting experience by displaying the current user's name combined with customizable welcome messages. Messages are configured at the app level and automatically localized to the user's preferred language. When multiple messages are configured, the widget randomly selects one for each page load to provide variety.
+
+The widget retrieves the logged-in user's display name and substitutes it into a message template using the `<name>` placeholder. For example, "Welcome back, <name>!" renders as "Welcome back, John Doe!". If no custom messages are configured, the widget simply displays the user's name.
+
+## Use Cases
+
+### Landing Page Personalization
+
+Create a welcoming, personalized experience when users access the platform. The widget is specifically designed for landing pages and dashboards to greet users by name upon login.
+
+**Example Scenarios:**
+
+- **Corporate Intranet Landing Page**: Display "Good morning, <name>!" or "Welcome to the Team Portal, <name>!" to acknowledge users when they access the company workspace
+- **Project Dashboard Entry Point**: Show "Welcome back, <name>! Here's your project overview" to orient users returning to a project workspace
+- **Multi-Language Environment**: Configure different greetings in multiple languages (e.g., "Willkommen zuruck, <name>!" in German, "Welcome back, <name>!" in English) that automatically display in the user's preferred language
+
+### Randomized Greetings for Variety
+
+Configure multiple welcome messages to add freshness and variety to the user experience. The widget randomly selects one message each time the page loads.
+
+**Example Messages:**
+- "Hello, <name>!"
+- "Great to see you, <name>!"
+- "Welcome, <name>!"
+
+## Design Considerations
+
+### App-Level Configuration
+
+Welcome messages are configured at the **app level** (per workspace), not per widget instance. This means all instances of this widget in a workspace share the same message pool. Configuration is done through the Landing Page from Page app settings.
+
+### Display Characteristics
+
+The widget renders with no frame/border and no internal padding, making it ideal for seamless integration into landing page designs. It uses a minimal wrapper div for styling flexibility.
+
+### Prerequisites
+
+- The "Landing Page from Page" app must be enabled in the workspace
+- Welcome messages should be configured in the app settings for meaningful output
+- The user must be logged in (anonymous users would have no name to display)
+
+## Related Widgets
+
+The widget is part of the Landing Page from Page app (`cf.cplace.landingPageFromPage`), which provides functionality for creating landing pages within cplace workspaces.
+
+**Other widgets in the same plugin:**
+- **Quick Overview** (`cf.cplace.landingPageFromPage.quickOverview`): Shows at-a-glance search results with hit counts
+- **Simple List Overview** (`cf.cplace.landingPageFromPage.simpleListWithNewAttachment`): Displays search results as a list with icons and create-new functionality

package/dist/widget-specifications/cf.cplace.landingPageFromPage.sessionUserNameWidget/_summary.md

@@ -0,0 +1 @@
+Displays the username and a customizable greeting message, randomly selected from configurable localized greetings.

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

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.landingPageFromPage.simpleListWithAttachment",
+  "Description": "{\"en\":\"Shows all the pages for a search along with icons\",\"de\":\"Zeigt alle Seiten für eine Suche zusammen mit Symbolen an\"}",
+  "Localized Name": "{\"en\":\"Simple List Overview\",\"de\":\"Einfache Listen-Übersicht\"}",
+  "Icon": "fa-list-alt",
+  "Plugin": "cf.cplace.landingPageFromPage",
+  "App": "cf.cplace.landingPageFromPage",
+  "Localized App Name": "{\"en\":\"Landing Page from a cplace Page\",\"de\":\"Landing Page aus einer cplace-Seite\"}",
+  "Repository": "cplace-paw",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.landingPageFromPage.simpleListWithAttachment/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "attributes",
+    "list",
+    "searchable",
+    "navigation",
+    "dashboard"
+  ],
+  "requiredApp": "cf.cplace.landingPageFromPage"
+}

package/dist/widget-specifications/cf.cplace.landingPageFromPage.simpleListWithAttachment/_overview.md

@@ -0,0 +1,53 @@
+## Overview
+
+Shows all the pages for a search along with icons.
+
+The Simple List Overview widget provides a streamlined way to display a curated list of pages on landing pages and dashboards. Each list item shows the page name, an optional subtitle using attribute patterns, and an optional icon derived from an enumeration attribute. The widget includes built-in support for creating new items directly via an "Add New" button.
+
+This widget is part of the Landing Page from Page plugin (`cf.cplace.landingPageFromPage`), which enables creating custom landing pages within workspaces.
+
+## Use Cases
+
+### Landing Page Quick Access Lists
+Display frequently accessed items (recent documents, active projects, tasks) on a landing page dashboard. Users can quickly scan and navigate to relevant items.
+
+### Category-Specific Item Lists
+Show items filtered by search criteria such as "My Open Tasks", "Active Projects", or "Pending Approvals". Each list can be configured to show only relevant items for a specific context.
+
+### Item Creation Entry Point
+Provide users a convenient way to create new items directly from the list. The "New [ItemType]" button streamlines workflows by reducing navigation steps.
+
+### Visual Item Categorization
+Use enumeration-based icons to visually distinguish item types or statuses at a glance. Subtitles can display additional context like dates, owners, or status information.
+
+## Design Considerations
+
+### When to Use This Widget
+- When you need a simple, scrollable list of items on a landing page
+- When users should be able to create new items directly from the list
+- When items need visual differentiation through icons or status indicators
+- When subtitle information helps users identify items quickly
+
+### When NOT to Use This Widget
+- When you need advanced table features (sorting, filtering, grouping) - use a table widget instead
+- When you need to display many attributes per item - use a table widget instead
+- When you need hierarchical/tree views
+- When items don't have a natural list representation
+
+### Search Limitations
+- Search should typically be limited to a single space and type
+- Multi-space searches disable the create button functionality
+- For icon display, the searched type must have an enumeration attribute with associated icons
+
+## Alternatives
+
+| Widget | When to Use Instead |
+|--------|---------------------|
+| **Quick Overview** (`cf.cplace.landingPageFromPage.quickOverview`) | When you need aggregate statistics and hit counts rather than a scrollable list |
+| **Embedded Search as List** (`cf.platform.embeddedSearchAsList`) | When you need more advanced list features or master-detail patterns |
+| **Embedded Search as Table** (`cf.platform.embeddedSearchAsTable`) | When you need sortable columns, filtering, or multiple visible attributes |
+
+## Related Patterns
+
+- **Landing Page Dashboard** - Combine with Quick Overview and Welcome Message widgets for a complete landing page experience
+- **Quick Navigation** - Use alongside navigation tiles for different navigation approaches on the same page

package/dist/widget-specifications/cf.cplace.landingPageFromPage.simpleListWithAttachment/_summary.md

@@ -0,0 +1 @@
+Shows all the pages for a search along with icons, with optional subtitles and a button to create new items directly from the widget.

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

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.layoutTabsWidget.widget",
+  "Description": "{\"en\":\"Enables you to organize different layout alternatives of a type in tabs.\",\"de\":\"Ermöglicht, unterschiedliche Layoutalternativen eines Typs in Tabs zu organisieren.\"}",
+  "Localized Name": "{\"en\":\"Alternative Layouts as Tabs\",\"de\":\"Alternative Layouts als Tabs\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.layoutTabsWidget",
+  "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 'Alternative Layouts as Tabs' widget can be used to display alternative layouts of the current type or page in the form of tabs on a cplace page.</p>\n\n<p><strong>Key Benefits</strong></p>\n\n<ul>\n\t<li>Widgets and information contained on a page can be structured and arranged in a meaningful manner.</li>\n</ul>\n\n<p><strong>Settings</strong></p>\n\n<p>// * Layout configuration*: Shows the current layout configuration as a list of the selected layouts in the order in which their tabs are displayed, followed by the active layout.</p>\n\n<p>// * Layouts to show:</p>\n\n<p>// * Active layout: The layout to be used when the page is opened initially.</p>"
+}

package/dist/widget-specifications/cf.cplace.layoutTabsWidget.widget/_implementation.md

@@ -0,0 +1,6 @@
+**Typical Configuration Workflow (Basic Mode)**:
+1. Set `sourceForLayouts` to `simpleLayoutSelection`
+2. Select which alternative layouts to show as tabs via `layouts`
+3. Optionally set the initially active tab via `layoutSelection`
+
+**Note**: The page type must have alternative type layouts defined for this widget to function.

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

@@ -0,0 +1,7 @@
+{
+  "tags": [
+    "container",
+    "navigation"
+  ],
+  "requiredApp": null
+}

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

@@ -0,0 +1,115 @@
+## Overview
+
+Enables you to organize different layout alternatives of a type in tabs.
+
+The Alternative Layouts as Tabs widget can be used to display alternative layouts of the current type or page in the form of tabs on a cplace page. This allows widgets and information contained on a page to be structured and arranged in a meaningful manner.
+
+## Use Cases
+
+### Hub-and-Spoke Navigation
+When an entity page needs to expose many functional areas from a single location. Users land on a summary view and can drill into specialized layouts (board view, checklist, attachments, permissions) through tabs. This pattern works well for complex entities like schedules or projects where users need quick access to various operational aspects.
+
+### Dashboard View Switching
+Dashboards often benefit from offering multiple visualization modes. A resource management dashboard might provide tabs for planning view, Gantt timeline, and manager overview. Users can switch perspectives while maintaining the same data context.
+
+### Role-Based Interface Organization
+Pages used by multiple user roles can organize tabs by workflow. Operational tabs appear first for daily users, while administrative or configuration tabs appear later for managers or administrators.
+
+### Focused Subset Exposure
+Not all alternative layouts need to appear as tabs. A page might have 13 alternative layouts but only expose 2 as tabs, with other layouts accessible through navigation tiles or direct URLs. This keeps the tab bar manageable while preserving full functionality.
+
+## Behavior and Capabilities
+
+### How It Works
+
+The Layout Tabs Widget acts as a container that renders alternative type layouts as tabs. Each tab displays a completely different layout with its own widgets and configuration. The page context (current page UID) is preserved across tab switches.
+
+```
++-------------------------------------------------------------------------+
+|  Layout Tabs Widget                                                      |
+|  +---------+-------------+----------+----------+----------+             |
+|  | Board   | Checklist   | Gantt    | Settings | Files    |  <- Tab Bar |
+|  +---------+-------------+----------+----------+----------+             |
++-------------------------------------------------------------------------+
+|                                                                          |
+|              (Selected alternative layout renders here)                  |
+|                                                                          |
+|              Each tab loads a completely different layout                |
+|              with its own widgets and configuration                      |
+|                                                                          |
++-------------------------------------------------------------------------+
+```
+
+### Prerequisite: Alternative Layouts
+
+The widget does not create layouts. It only provides navigation between existing alternative layouts that must be defined at the type level first. If a type has no alternative layouts, this widget has nothing to display.
+
+### Tab Content Loading
+
+Tab content is lazy loaded on first activation. This means the initial page load is fast, and each tab's widgets only load when the user clicks that tab for the first time. Subsequent switches to a previously loaded tab are instantaneous.
+
+### URL and History Integration
+
+Tab selection updates the URL with a layout parameter, enabling bookmarking and sharing of specific tab views. Browser back/forward navigation works with tab history, providing a natural browsing experience.
+
+### Localization
+
+Tab labels come from the alternative layout's localized names. No additional localization configuration is needed within the widget itself.
+
+### Configuration Modes
+
+The widget supports two approaches for determining which tabs to display:
+
+**Static Selection**: A predefined list of alternative layout names. Tab order matches the list order. This approach is simpler and covers most use cases.
+
+**Dynamic Script Selection**: A script that determines tabs at runtime. Useful for permission-based tab visibility, conditional tabs based on page attributes, or dynamic tab ordering. This adds complexity but enables sophisticated scenarios.
+
+## Design Considerations
+
+### Tab Count and Cognitive Load
+
+Too many tabs overwhelm users. Aim for 2-7 tabs that represent meaningfully distinct views. If more views are needed, consider using navigation tiles for overflow or organizing into fewer, broader categories.
+
+### Tab Ordering Strategy
+
+Place the most frequently used tabs first to minimize clicks for common tasks. Administrative or rarely-used tabs belong at the end. Consider the typical user journey when ordering.
+
+### Consistent Tab Heights
+
+When layouts within tabs have wildly different heights, the page can feel jarring as users switch between tabs. Strive for consistent widget heights across alternative layouts to create smooth visual transitions.
+
+### Placement in Page Layout
+
+The widget works best at the bottom of a page layout, after summary content. A common pattern uses progressive disclosure:
+
+1. Navigation or context information at the top (Where am I?)
+2. Summary visualizations in the middle (How are we doing?)
+3. Layout tabs at the bottom for detailed views (Let me explore)
+
+Full-width placement (spanning all columns) provides the most space for tab content.
+
+### When Not to Use Layout Tabs
+
+Avoid this widget when the views represent fundamentally different entities rather than perspectives on the same entity. If switching tabs feels like navigating to a different page conceptually, separate pages with their own URLs might be more appropriate.
+
+Consider navigation tiles instead when the visual presentation of cards with icons and descriptions would better communicate the available options, or when you want a more prominent, intentional navigation choice rather than quick tab switching.
+
+## Related Widgets
+
+### Navigation Tiles
+Provides card-based navigation with visual tiles. Use Navigation Tiles for more prominent, intentional navigation choices. Use Layout Tabs for quick perspective switching within the same context.
+
+### Breadcrumb Widget
+Helps orient users within the page hierarchy. Often paired with layout tabs on complex pages where users need both hierarchical context and horizontal perspective switching.
+
+### Search Widgets in Tabs
+Alternative layouts displayed in tabs commonly contain search-based widgets (embedded search as table, board widget). The tab becomes a container for these operational views while the default layout provides the summary.
+
+## Evidence
+
+Layouts where this widget was analyzed:
+- `01-schedule-default`: 7 tabs, hub-and-spoke pattern
+- `02-dashboardScheduleTm-default`: 2 tabs, selective exposure
+- `03-dashboardProjectRM-default`: 6 tabs, full exposure with default selection
+
+See: `specs/2026-01-04-widget-analyzer/analyses-layout-tabs-widget/`

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

@@ -0,0 +1 @@
+Enables you to organize different layout alternatives of a type in tabs, allowing users to switch between different layout views of the same page.

package/dist/widget-specifications/cf.cplace.layoutTabsWidget.widget/cf.cplace.layoutTabsWidget.layoutSelection.md

@@ -0,0 +1,2 @@
+**Purpose**: Set which layout tab is shown initially when the page loads.
+**Valid Values**: The internal names of te alternative type layout to show initially

package/dist/widget-specifications/cf.cplace.layoutTabsWidget.widget/cf.cplace.layoutTabsWidget.layouts.md

@@ -0,0 +1,3 @@
+**Purpose**: Select which alternative layouts of the page type should appear as tabs.
+
+**Valid Values**: The internal names of alternative type layouts serialized as a JSON array. Use `cplace_list_type_alternative_layouts` to see available layouts for the type.

package/dist/widget-specifications/cf.cplace.layoutTabsWidget.widget/cf.cplace.layoutTabsWidget.sourceForLayouts.md

@@ -0,0 +1 @@
+**Purpose**: Determines which mode is active: Set to `simpleLayoutSelection` → Basic Mode

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

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.lowCodeWidgets.lowCodeButton",
+  "Description": "{\"en\":\"This widget displays a button that runs a Low-Code script when clicked.\",\"de\":\"Dieses Widget gibt eine Schaltfläche aus, die beim Anklicken ein Low-Code-Skript ausführt.\"}",
+  "Localized Name": "{\"en\":\"Low-Code Button\",\"de\":\"Low-Code Button\"}",
+  "Icon": "fa-code",
+  "Plugin": "cf.cplace.lowCodeWidgets",
+  "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.lowCodeWidgets.lowCodeButton/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "low-code",
+    "connected",
+    "searchable",
+    "selectable",
+    "dashboard"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.cplace.lowCodeWidgets.lowCodeButton/_overview.md

@@ -0,0 +1,149 @@
+## Overview
+
+This widget displays a button that runs a Low-Code script when clicked.
+
+The Low-Code Button widget is an interactive widget that allows administrators and low-code developers to embed custom automation logic into cplace pages through a button interface. When clicked, the button executes a configurable JavaScript script that has access to contextual data from the page, connected widgets, and data sources.
+
+The widget bridges the gap between no-code page building and full custom development by providing a scriptable button interface with rich access to page data, search results, and user selections.
+
+## Use Cases
+
+### Data Processing and Transformation
+Execute custom business logic to process or transform data on the current page or related entities:
+- Calculate and update aggregate values across multiple pages
+- Transform data formats or structures
+- Apply custom validation rules
+- Generate derived data based on complex business rules
+
+### Bulk Operations on Selected Items
+Perform actions on multiple items selected in a connected table widget:
+- Bulk update attributes across selected pages
+- Mass approve/reject workflow items
+- Batch delete or archive records
+- Apply consistent changes to a selection of entities
+
+### External System Integration
+Trigger integrations with external systems or services:
+- Call external APIs to synchronize data
+- Send notifications to external systems
+- Export data to external formats
+- Import data from external sources
+
+### Workflow and Process Automation
+Automate workflow steps and business processes:
+- Trigger state transitions
+- Start background jobs for long-running processes
+- Execute multi-step approval processes
+- Orchestrate complex business workflows
+
+### Report Generation and Data Export
+Generate custom reports or export data:
+- Create formatted reports based on search results
+- Export data in custom formats
+- Generate summary statistics
+- Create audit logs or change histories
+
+### User Interaction with Confirmation
+Present users with action buttons that require confirmation:
+- Delete operations requiring user confirmation
+- Critical actions that need explicit approval
+- Operations that collect additional input before execution
+
+## Operating Modes
+
+### Synchronous Execution
+Script runs in the current request context:
+- Limited to default script timeout (typically 60 seconds)
+- Suitable for quick operations that need immediate feedback
+- Log output is not displayed to the user
+- Script completes before page control returns to user
+
+### Asynchronous Execution (Default)
+Script runs as a background job:
+- A background job is created and tracked
+- Users receive a link to monitor job progress
+- Script output via `log.logText()` and `log.logHtml()` is captured in the job log
+- Suitable for long-running operations
+- User can continue working while script executes
+
+## Design Considerations
+
+### When to Use This Widget
+
+Use the Low-Code Button widget when you need to:
+- Execute custom business logic that cannot be achieved with standard cplace features
+- Automate repetitive tasks directly from the page interface
+- Integrate with external systems through custom code
+- Process multiple items based on user selection
+- Provide users with action buttons that execute context-specific logic
+
+### Data Source Options
+
+The widget supports multiple ways to provide data to the script:
+
+**Search-based**: Define a search query whose results are available as the `pages` binding. Use when you need to process a dynamic set of pages matching specific criteria.
+
+**Connected Table**: Connect to a table widget on the same page to process selected rows. Use when users need to explicitly select which items to process. Supports nested connected tables for complex scenarios.
+
+**Manual Selection**: Manually select specific pages to provide as the `pages` binding. Use when the set of pages is fixed and known at configuration time.
+
+**All Search Results**: Provides raw search results (not just pages) in the `searchResults` binding. Use when you need access to search metadata beyond just the page objects.
+
+### Script Structure Requirements
+
+Every Low-Code Button script must return an object with two methods:
+
+**`checkAccess()`**: Controls button availability based on context. Evaluated when the page loads. Returns `true` to enable the button, `false` to disable it. Does not have access to the `log` binding.
+
+**`call()`**: Contains the actual business logic executed when the button is clicked. Has access to all script bindings including the `log` binding for user output. Can optionally return a success message or job ID.
+
+### Integration with Other Widgets
+
+The Low-Code Button widget can be:
+- **Embedded in**: Attribute Group widgets or Connected Attribute Group widgets
+- **Connected to**: Embedded Search as Table widgets (to access selected rows)
+- **Nested**: Can work with connected tables that are themselves connected to other tables
+
+### User Interaction Enhancements
+
+**Confirmation Dialogs**: Prompt users before script execution for critical operations. Customizable message and button labels.
+
+**Additional Data Collection**: Display a dialog to collect additional input before script execution. Configure any cplace type to define the input fields needed.
+
+## Common Pitfalls
+
+- **Synchronous timeout**: Synchronous execution is limited to 60 seconds by default. Use asynchronous mode for long-running operations.
+- **Access control oversight**: The `checkAccess()` method is only evaluated on page load, not on every click. Dynamic conditions should be rechecked in the `call()` method if needed.
+- **Missing data source**: Scripts expecting the `pages` binding will fail if no data source is configured.
+- **Log output ignored**: In synchronous mode, `log.logText()` and `log.logHtml()` output is not displayed to users.
+
+## Testing Before Embedding
+
+Before embedding a Low-Code Button widget into a rich string attribute, test your cplaceJS script independently to verify it works correctly.
+
+**Recommended workflow:**
+1. Write your cplaceJS script (with `checkAccess()` and `call()` methods)
+2. Test the `call()` logic using `cplace_execute_script` with a representative page as the context page
+3. Verify the script executes without errors and produces the expected result
+4. Only then embed the widget via `cplace_richstring_insert_widget` with the tested script in the properties
+
+**Why this matters:** A script with errors will produce a broken button once embedded. Debugging scripts inside embedded widgets is significantly harder than debugging them standalone, because the embedded widget rendering does not surface script errors clearly.
+
+## Permissions and Access Control
+
+- **Embedding Permission**: Only users with "Low-Code permission" (`GlobalPermissions.mayEditLowCode()`) can embed this widget
+- **Script Editing**: The script attribute is only visible/editable to users with Low-Code permission
+- **Runtime Access Control**: The `checkAccess()` method provides dynamic access control based on context
+
+## Related Widgets
+
+### Low-Code Text Widget
+Displays computed text/HTML instead of executing actions. Both widgets share similar data source configurations and script bindings but serve different purposes:
+- **Low-Code Button**: Imperative, user-triggered actions
+- **Low-Code Text Widget**: Declarative, auto-updated display
+
+### Embedded Search as Table
+Often used as a connected data source for the Low-Code Button. The table widget provides the selection of pages that the button script processes.
+
+### Attribute Group Widgets
+Common embedding containers for Low-Code Button widgets, allowing the button to be positioned alongside other page content.

package/dist/widget-specifications/cf.cplace.lowCodeWidgets.lowCodeButton/_summary.md

@@ -0,0 +1 @@
+Displays a button that runs a Low-Code script when clicked, enabling users to automate business logic and actions directly from the page interface.

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

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.lowCodeWidgets.lowCodeText",
+  "Description": "{\"en\":\"This widget executes a Low-Code script and renders the result as text/HTML within a rich string widget.\",\"de\":\"Dieses Widget f\\u00fchrt ein Low-Code-Skript aus und gibt das Ergebnis als Text/HTML innerhalb eines Rich-String-Widgets aus.\"}",
+  "Localized Name": "{\"en\":\"Low-Code Text\",\"de\":\"Low-Code Text\"}",
+  "Icon": "fa-code",
+  "Plugin": "cf.cplace.lowCodeWidgets",
+  "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.lowCodeWidgets.lowCodeText/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "low-code",
+    "rich-text",
+    "connected",
+    "searchable",
+    "read-only",
+    "dashboard"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.cplace.lowCodeWidgets.lowCodeText/_overview.md

@@ -0,0 +1,94 @@
+## Overview
+
+This widget executes a cplaceJS script and renders the result as inline HTML content within a rich string widget.
+
+The Low-Code Text widget enables dynamic, script-computed content to be embedded directly within rich text layouts. On page load, the widget evaluates a JavaScript script with access to contextual data (pages from search, connected tables, or explicit selections) and renders the returned value as HTML. When connected to a table widget, it reactively re-evaluates whenever the table's data or user selection changes, enabling live-updating computed content without page reload.
+
+## Use Cases
+
+### Dynamic Computed Values in Rich Text
+Display calculated or derived information inline within formatted page content:
+- Aggregated metrics (sums, averages, counts) from search results
+- Conditional text based on page attributes or states
+- Formatted summaries combining data from multiple sources
+
+### Reactive Content Linked to Tables
+Create text that updates when users interact with connected table widgets:
+- Details about selected table rows
+- Summary statistics that update as the table data changes
+- Context-specific information based on the current table selection
+
+### Data-Driven HTML Rendering
+Generate custom HTML markup based on page data:
+- Visual indicators (colored badges, progress bars) based on attribute values
+- Mini-tables or formatted lists from search results
+- Formatted dates, numbers, or computed expressions
+
+### Internationalized Dynamic Content
+Generate localized content using the `messages` binding to display status messages, computed text, or dynamic values in the user's language.
+
+## Script Return Values
+
+The script simply returns a value to display (no object structure required, unlike the Low-Code Button):
+- **String**: Rendered as HTML (sanitized)
+- **Number/Boolean/Date**: Converted to string
+- **Localized object**: `{en: "Hello", de: "Hallo"}` -- resolved to user's language
+
+## Data Source Options
+
+The widget supports three data source modes (identical to the Low-Code Button):
+
+**Search**: Define a search query whose results are passed as the `pages` binding. Most common mode.
+
+**Connected Table**: Connect to a table widget on the same page. The widget re-evaluates when the table's data changes or when the user's selection changes (if "selection only" is enabled). Supports chained connected tables.
+
+**Selection**: Manually select specific pages to provide as the `pages` binding.
+
+Additionally, **Include All Search Results** can be enabled to provide raw search results (including non-page entities) via the `searchResults` binding.
+
+## Embedding Constraint
+
+This widget can **only** be embedded inside rich string widgets. It cannot be placed directly on a page layout. It renders without a frame and without padding, blending seamlessly into surrounding rich text content.
+
+## Design Considerations
+
+### When to Use This Widget
+- You need dynamic, script-computed content within a rich text layout
+- The content should update reactively based on connected table interactions
+- You want inline computed values (metrics, status text, formatted data) mixed with static rich text
+
+### When NOT to Use This Widget
+- For user-triggered actions -- use the **Low-Code Button** instead
+- For standalone chart visualizations -- use **cplaceJS Highcharts** or **cplaceJS Line Chart**
+- For simple static text -- use the **Rich String** widget directly
+
+### Script Execution Considerations
+- Scripts execute synchronously during page rendering and on every re-evaluation
+- Keep scripts performant to avoid slow page loads
+- Output HTML is sanitized via `RichStringUtilities.clean()` for security
+
+## Testing Before Embedding
+
+Before embedding a Low-Code Text widget into a rich string attribute, test your cplaceJS script independently to verify it produces the expected output.
+
+**Recommended workflow:**
+1. Write your cplaceJS script
+2. Run it using `cplace_execute_script` with a representative page as the context page
+3. Verify the returned HTML/text is correct
+4. Only then embed the widget via `cplace_richstring_insert_widget` with the tested script in the properties
+
+**Why this matters:** A script with errors or unexpected output will produce a broken or empty widget once embedded. Debugging scripts inside embedded widgets is significantly harder than debugging them standalone, because the embedded widget rendering does not surface script errors clearly.
+
+## Related Widgets
+
+### Low-Code Button (`cf.cplace.lowCodeWidgets.lowCodeButton`)
+The imperative counterpart: executes user-triggered actions on click. Shares the same data source configuration and script bindings but uses a different script structure (`checkAccess()`/`call()` methods).
+
+### Rich String (`cf.platform.richString`)
+The typical host widget for Low-Code Text. The rich string provides the static layout structure; embedded Low-Code Text widgets provide dynamic content within it.
+
+### Text without Widget Frame (`cf.cplace.demoWidgets.demoRichString`)
+An alternative host widget -- a frameless rich string variant also capable of embedding Low-Code Text widgets.
+
+### Embedded Search as Table (`cf.platform.embeddedSearchAsTable`)
+Often used as the connected data source. The table widget provides data or selection events that trigger the Low-Code Text to re-evaluate.

package/dist/widget-specifications/cf.cplace.lowCodeWidgets.lowCodeText/_summary.md

@@ -0,0 +1 @@
+Executes a cplaceJS script and renders the returned text or HTML inline within a rich string widget. Reactively re-evaluates when connected table data or selections change.