@cplace/mcp-server 1.3.14

package/dist/widget-specifications/cf.projektplanung.multiGantt/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "timeline",
+    "tree",
+    "time-series",
+    "scheduling",
+    "dashboard",
+    "connected"
+  ],
+  "requiredApp": "cf.cplace.projektplanung.projektplanungBasic"
+}

package/dist/widget-specifications/cf.projektplanung.multiGantt/_overview.md

@@ -0,0 +1,73 @@
+## Overview
+
+The Multi Gantt Chart widget displays any number of schedules at the same time, which are pre-selected in the widget configuration. It aggregates multiple schedules into a unified timeline visualization, enabling stakeholders to see consolidated project timelines at a glance.
+
+**Use when**:
+- Building project dashboards that need to show all associated schedules
+- Creating portfolio-level views across multiple projects or programs
+- Providing executive summaries of timeline status across organizational units
+
+**Alternatives**:
+- **Single Gantt Link**: When you only need to preview a single schedule
+- **Schedule Tree Table**: When tabular WBS data is more appropriate than timeline visualization
+
+## Use Cases
+
+### Project Timeline Dashboard
+A project manager needs visibility into all schedules related to their project. The Multi-Gantt consolidates schedules that are either direct children of the project or linked through additional associations, presenting them in one interactive timeline.
+
+### Portfolio Overview
+Program managers and executives need to monitor multiple projects simultaneously. The widget can aggregate schedules across a filtered set of projects, enabling cross-project timeline comparison and dependency awareness.
+
+### Status Reporting Views
+For stakeholder communication, a read-only aggregated view provides timeline context without the risk of accidental modifications. This supports status meetings and reporting workflows where visibility matters more than editability.
+
+## Behavior and Capabilities
+
+### Schedule Aggregation
+The widget discovers schedules through search-based filtering. This allows flexible aggregation strategies:
+- Schedules directly owned by a project
+- Schedules linked through reference attributes
+- Schedules matching arbitrary search criteria
+
+The dual-path discovery pattern (parent reference OR link reference) is common, ensuring schedules are found regardless of how they relate to the containing page.
+
+### Expansion Control
+Users can control how much detail appears initially. The widget supports starting fully expanded (all tasks visible), partially expanded (schedule headers visible, tasks hidden), or fully collapsed (compact summary). This lets designers balance information density against cognitive load.
+
+### Read-Only Mode
+The widget can operate in read-only mode, preventing inline edits while preserving visualization and navigation capabilities. This is essential for aggregation views where editing should happen at the individual schedule level.
+
+### Cross-Schedule Dependencies
+Dependency relationships between schedules can be shown or hidden. Showing dependencies reveals cross-schedule coordination requirements; hiding them reduces visual complexity for overview purposes.
+
+### Sorting
+Schedules can be ordered by various attributes, most commonly by name for intuitive alphabetical navigation.
+
+## Design Considerations
+
+### Information Density Trade-offs
+Aggregating many schedules creates information overload risk. Design decisions to mitigate this:
+- Start collapsed to give users control over what they expand
+- Hide cross-links in overview contexts to reduce visual noise
+- Use read-only mode to signal "viewing" rather than "editing" intent
+
+### Editing Context
+Multi-Gantt is fundamentally an aggregation view. While it can support editing, the recommended pattern is to use it for overview and navigation, directing users to individual schedule views for detailed editing. This prevents confusion about which schedule they're modifying.
+
+### Performance Awareness
+Large aggregations (many schedules with many tasks) can impact performance. For portfolio-level views spanning many projects, consider filtering strategies or pagination approaches to keep the visualization responsive.
+
+### Search Filter Design
+The search mechanism is powerful but requires careful filter construction. The common pattern of searching for schedules via multiple reference paths (parent AND link) provides flexibility but adds complexity. Test filter logic thoroughly before deployment.
+
+## Related Widgets
+
+### Single Gantt Link
+**Single Gantt Link** provides a lightweight preview of a single schedule. Use it when embedding schedule context without the full multi-schedule aggregation overhead. It's a simpler choice when only one schedule is relevant.
+
+### Schedule Tree Table
+**Schedule Tree Table** presents WBS (Work Breakdown Structure) data in tabular form rather than timeline form. Choose it when users need to see task details, assignments, or other attributes that don't fit well in a Gantt visualization.
+
+### Complementary Pattern
+A common layout pattern places Multi-Gantt on a dedicated "Timeline" or "Gantt" tab, keeping the main page cleaner while providing focused timeline access. This separates timeline visualization from other project information widgets.

package/dist/widget-specifications/cf.projektplanung.multiGantt/_summary.md

@@ -0,0 +1 @@
+Displays any number of schedules at the same time, which are pre-selected in the widget configuration. Use for project dashboards, portfolio views, or executive summaries showing consolidated timelines across multiple schedules.

package/dist/widget-specifications/cf.projektplanung.scheduleTreeTable/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.projektplanung.scheduleTreeTable",
+  "Description": "{\"en\":\"Shows tasks and milestones of one or more schedules in a tree table.\",\"de\":\"Zeigt Vorgänge und Meilensteine eines oder mehrerer Pläne in einer Strukturtabelle an.\"}",
+  "Localized Name": "{\"en\":\"Structured Table for Schedules\",\"de\":\"Strukturtabelle für Pläne\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.projektplanung",
+  "App": "cf.cplace.projektplanung.projektplanungBasic",
+  "Localized App Name": "{\"en\":\"Project Planning (Basic)\",\"de\":\"Projektplanung (Basis)\"}",
+  "Repository": "cplace-project-planning",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.projektplanung.scheduleTreeTable/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "table",
+    "tree",
+    "time-series",
+    "scheduling",
+    "inline-edit"
+  ],
+  "requiredApp": "cf.cplace.projektplanung.projektplanungBasic"
+}

package/dist/widget-specifications/cf.projektplanung.scheduleTreeTable/_overview.md

@@ -0,0 +1,84 @@
+## Overview
+
+The Structured Table for Schedules widget shows tasks and milestones of one or more schedules in a tree table. It displays a schedule's work breakdown structure (WBS) as an interactive, hierarchical table, providing a spreadsheet-like interface where users can view and edit task properties while navigating through the project hierarchy using expand/collapse controls.
+
+**Use when**: Users need to work with task data in a structured, tabular format. This is ideal for data-centric editing tasks such as updating dates, durations, progress percentages, and assignments across multiple tasks. The familiar spreadsheet paradigm makes it accessible to users who prefer working with rows and columns over visual timelines.
+
+**Alternatives**:
+- **Single Gantt Link**: When timeline visualization and dependency relationships are more important than tabular editing
+- **Embedded Search as Table**: When displaying a flat list of tasks without hierarchical structure
+- **Multi-Gantt**: When aggregating tasks across multiple schedules in a timeline view
+
+## Use Cases
+
+### Project Managers Updating Task Details
+A project manager needs to update start dates, end dates, and progress percentages for multiple tasks. The tabular format allows rapid data entry, similar to working in a spreadsheet, without needing to open each task individually.
+
+### Work Breakdown Structure Review
+During planning sessions, teams review the complete task hierarchy to ensure nothing is missing. The expandable tree structure lets them drill down into specific areas while maintaining context of the overall project structure.
+
+### Status Reporting and Progress Tracking
+Managers review task completion status across the project. The tabular view provides a quick scan of progress percentages and status indicators, making it easy to identify tasks that are behind schedule.
+
+### Resource Assignment
+When assigning team members to tasks, the table format allows users to see all assignments at once and make bulk updates to the responsible person column.
+
+## Behavior and Capabilities
+
+### Hierarchical Navigation
+The widget presents tasks in a tree structure that mirrors the project's work breakdown structure. Parent tasks can be expanded to reveal child tasks, and the entire hierarchy can be navigated through expand/collapse controls. This preserves the logical grouping of work while allowing users to focus on specific areas.
+
+### Inline Editing
+Unlike read-only table views, the Schedule Tree Table supports direct editing of task properties within the table cells. Users can modify values without navigating away from the overview, enabling efficient bulk updates.
+
+### Schedule Context Awareness
+The widget understands its context within cplace. It can automatically display tasks from the schedule page it's embedded in, or it can be configured to find schedules through search criteria or reference attributes. This flexibility allows the same widget to serve different architectural patterns.
+
+### Automatic Column Selection
+Standard schedule-relevant columns are included automatically, covering the essential task properties: names, dates, durations, progress, status indicators, and assignments. This reduces configuration overhead while ensuring users see the information they need.
+
+## Design Considerations
+
+### When to Choose Tree Table Over Gantt
+The Tree Table and Gantt views represent complementary perspectives on the same data:
+
+- **Choose Tree Table** when users primarily need to edit data values, perform bulk updates, or review detailed properties across many tasks. The tabular format excels at data manipulation.
+
+- **Choose Gantt** when users need to understand temporal relationships, visualize dependencies, or see how tasks fit together on a timeline. The visual format excels at schedule comprehension.
+
+Many solutions offer both views, allowing users to switch based on their current task.
+
+### Height and Scrolling Trade-offs
+Fixed height widgets create predictable layouts but require scrolling for large schedules. Consider the typical schedule size in your solution:
+- Smaller heights keep the widget compact but require more scrolling
+- Larger heights show more tasks at once but consume more screen space
+- Very large schedules may benefit from pagination or filtering strategies
+
+### Placement in Layout Architecture
+The Tree Table works well as a dedicated view within a tabbed layout. This separates the data-editing interface from other schedule views, letting users consciously choose their working mode. Placing it alongside a Gantt view on the same page can create visual competition and cognitive overload.
+
+### Performance with Large Hierarchies
+Deeply nested or very wide hierarchies may affect rendering performance. For schedules with hundreds of tasks, consider whether users actually need to see the entire structure at once, or whether filtering and drill-down patterns would serve them better.
+
+### Permission Boundaries
+Inline editing requires write permissions on the underlying tasks. The widget gracefully handles read-only access by displaying data without edit controls, but designers should consider whether users on a particular layout will have the necessary permissions.
+
+## Related Widgets
+
+### Single Gantt Link
+A timeline-focused view of the same schedule data. While the Tree Table emphasizes data manipulation, the Gantt emphasizes visual scheduling. They complement each other and are often offered as alternative views of the same schedule.
+
+### Multi-Gantt
+Aggregates tasks from multiple schedules into a single timeline view. Where the Tree Table focuses on one schedule's detailed structure, the Multi-Gantt provides cross-project visibility. They serve different analytical needs.
+
+### Embedded Search as Table
+A general-purpose table widget that can display any search results. Unlike the Tree Table, it doesn't understand hierarchical relationships or provide the specialized schedule-aware features. Use it when you need a flat task list without WBS navigation.
+
+### Layout Tabs Widget
+Often used as a container to offer users a choice between Tree Table and Gantt views. The fixed-height nature of the Tree Table works well within tabbed layouts where content area consistency matters.
+
+## Data Model Context
+
+The Schedule Tree Table operates on the cplace scheduling data model. It displays Activities and Milestones that belong to a Schedule, automatically traversing the parent-child relationships to build the tree structure. The widget understands how tasks nest within each other and represents this hierarchy through indentation and expand/collapse controls.
+
+This tight integration with the scheduling data model means the widget requires the Project Planning plugin (cf.projektplanung namespace) and must have access to a valid schedule context to function.

package/dist/widget-specifications/cf.projektplanung.scheduleTreeTable/_summary.md

@@ -0,0 +1 @@
+Shows tasks and milestones of one or more schedules in a tree table. Use when users need spreadsheet-like editing of task properties (dates, progress, assignments) while navigating the project hierarchy.

package/dist/widget-specifications/cf.projektplanung.singleGantt/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.projektplanung.singleGantt",
+  "Description": "{\"en\":\"Gantt chart of all tasks and milestones of this schedule.\",\"de\":\"Gantt-Diagramm aller Vorgänge und Meilensteine dieses Plans.\"}",
+  "Localized Name": "{\"en\":\"Gantt chart\",\"de\":\"Gantt-Diagramm\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.projektplanung",
+  "App": "cf.cplace.projektplanung.projektplanungBasic",
+  "Localized App Name": "{\"en\":\"Project Planning (Basic)\",\"de\":\"Projektplanung (Basis)\"}",
+  "Repository": "cplace-project-planning",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.projektplanung.singleGantt/_meta.json

@@ -0,0 +1,12 @@
+{
+  "tags": [
+    "timeline",
+    "chart",
+    "scheduling",
+    "tree",
+    "inline-edit",
+    "read-only",
+    "connected"
+  ],
+  "requiredApp": "cf.cplace.projektplanung.projektplanungBasic"
+}

package/dist/widget-specifications/cf.projektplanung.singleGantt/_overview.md

@@ -0,0 +1,27 @@
+## Overview
+
+The Gantt chart widget displays a Gantt chart of all tasks and milestones of this schedule. It automatically identifies the schedule context by traversing the page hierarchy upward to find the parent schedule, making it ideal for embedding on schedule-related pages without manual configuration.
+
+The widget provides complete Gantt chart functionality including task visualization, dependencies, timeline management, and optional inline editing capabilities. It can be configured with time range settings (absolute or relative dates), display options for initial expansion state, read-only mode, and control over cross-linked external tasks.
+
+## Use Cases
+
+- Display a comprehensive Gantt chart view on a schedule page directly
+- Show the parent schedule's Gantt view when viewing task or milestone detail pages
+- Provide context-aware Gantt visualization on custom pages within a schedule hierarchy
+- Enable visual project planning with timeline views for users working within a single project
+
+## Design Considerations
+
+Use the Single Gantt widget when you want automatic schedule detection based on the current page context. This is the preferred choice for schedule-centric views where users are working within a single project or schedule.
+
+The widget can be embedded on any page within a schedule's hierarchy - it will recursively traverse up the page hierarchy to find the parent schedule. This allows for flexible placement without requiring manual schedule configuration.
+
+Note that the Single Gantt widget cannot coexist with another Single Gantt or Multi Gantt widget on the same page. Configuration changes require a full page reload rather than inline updates due to the Gantt diagram's rendering mechanism.
+
+The "Without Cross-Links" option (enabled by default) controls whether tasks linked from outside the selected schedule are loaded, which affects performance and scope of displayed data.
+
+## Related Patterns/Alternatives
+
+- **Multi Gantt Widget** (`cf.projektplanung.gantt`): Displays multiple schedules simultaneously with explicit schedule selection, ideal for dashboards and cross-project comparisons
+- **Schedule Tree Widget** (`cf.cplace.projektplanung.scheduleTree`): Provides hierarchical view of schedules in tree/table format without timeline visualization

package/dist/widget-specifications/cf.projektplanung.singleGantt/_summary.md

@@ -0,0 +1 @@
+Displays a Gantt chart of all tasks and milestones of this schedule, automatically detecting the schedule context from the page hierarchy. It provides visual project planning capabilities with timeline visualization, task dependencies, and milestone tracking for a single schedule.

package/dist/widget-specifications/cf.projektplanung.singleGanttLink/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.projektplanung.singleGanttLink",
+  "Description": "{\"en\":\"A button that opens a Gantt chart in a new browser tab.\",\"de\":\"Eine Schaltfläche, die ein Gantt-Diagramm in einem neuen Browser-Tab öffnet.\"}",
+  "Localized Name": "{\"en\":\"Open Gantt Chart\",\"de\":\"Gantt-Diagramm öffnen\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.projektplanung",
+  "App": "cf.cplace.projektplanung.projektplanungBasic",
+  "Localized App Name": "{\"en\":\"Project Planning (Basic)\",\"de\":\"Projektplanung (Basis)\"}",
+  "Repository": "cplace-project-planning",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.projektplanung.singleGanttLink/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "timeline",
+    "time-series",
+    "scheduling",
+    "navigation",
+    "read-only"
+  ],
+  "requiredApp": "cf.cplace.projektplanung.projektplanungBasic"
+}

package/dist/widget-specifications/cf.projektplanung.singleGanttLink/_overview.md

@@ -0,0 +1,84 @@
+## Overview
+
+The Open Gantt Chart widget provides a button that opens a Gantt chart in a new browser tab. Rather than offering complete scheduling functionality inline, it acts as a visual entry point to the full Gantt chart experience, giving users immediate visual context while inviting them to explore the detailed view.
+
+**Use when**: You need to show a timeline teaser on overview or summary pages that links to the detailed Gantt experience. Ideal for default layouts where users want a quick visual sense of the schedule without the overhead of a full Gantt interface.
+
+**Alternatives**:
+- **Multi-Gantt** - When displaying multiple schedules in an aggregated view
+- **Schedule Tree Table** - When users need a tabular WBS structure with inline editing rather than a visual timeline
+
+## Use Cases
+
+### Schedule Overview Dashboard
+On a schedule's default page, users often want to see the timeline at a glance without committing to the full Gantt interface. The Single Gantt Link provides this preview, letting users quickly assess timeline health before deciding to dive deeper.
+
+### Project Summary Pages
+When creating executive summaries or project portfolio views that show one schedule per project, this widget offers a lightweight way to include timeline information without the performance cost of rendering a full Gantt for each project.
+
+### Navigation-Oriented Layouts
+In layouts designed around progressive disclosure, the Single Gantt Link serves as the visual "hook" that draws users toward the detailed Gantt view. It answers "what does the timeline look like?" and invites the follow-up question "what are the details?"
+
+### Read-Only Timeline Preview
+For stakeholders who need to see the timeline but don't need editing capabilities, this widget provides appropriate visual information without exposing planning controls.
+
+## Behavior and Capabilities
+
+### Schedule Source Selection
+The widget can obtain its schedule data through three mechanisms:
+- **Embedding context**: Uses the current page as the schedule, ideal when the widget lives directly on a schedule page
+- **Search-based selection**: Finds the appropriate schedule through search criteria, useful when embedding previews on related pages
+- **Reference following**: Traverses a reference attribute to locate the schedule, enabling indirect relationships
+
+### Timeline Rendering
+The widget renders the schedule's task hierarchy as a Gantt timeline, displaying activities as bars and milestones as diamonds. The rendering is intentionally simplified compared to the full Gantt view, prioritizing quick comprehension over exhaustive detail.
+
+### Dependency Visualization
+Cross-links between tasks (dependency arrows) can be shown or hidden. Hiding them results in a cleaner, less cluttered preview that's easier to scan quickly.
+
+### Navigation Behavior
+The "Link" in the widget name reflects its primary interaction model: clicking the preview navigates users to the full Gantt view where they can perform detailed planning and editing.
+
+## Design Considerations
+
+### Preview vs. Full Experience Trade-off
+This widget deliberately sacrifices functionality for simplicity. It answers "what does the timeline look like?" but not "how do I edit this task?" This separation of concerns keeps overview pages fast and focused while reserving the full feature set for dedicated planning views.
+
+Consider hiding dependency arrows in preview contexts. While dependencies are crucial for planning, they add visual complexity that can overwhelm a quick preview. The full Gantt view remains available for users who need dependency information.
+
+### Performance Implications
+As a lightweight preview widget, Single Gantt Link is designed for fast loading. This makes it suitable for pages where users expect quick access to information, such as default layouts or dashboard contexts. Avoid overloading the same page with multiple heavyweight widgets if this preview is meant to stay snappy.
+
+### Context Requirements
+The widget requires schedule context to function. When placing it on non-schedule pages, you must configure how the widget should find its schedule (through search or reference). On schedule pages, the embedding context typically provides the needed information automatically.
+
+### Plugin Dependency
+This widget is part of the Project Planning plugin (cf.projektplanung namespace). It's only available in workspaces where this plugin is installed and will not function in generic cplace environments.
+
+## Related Widgets
+
+### Within the Gantt Widget Family
+
+**Schedule Tree Table**: While Single Gantt Link provides a visual timeline preview, the Schedule Tree Table offers a tabular WBS view with inline editing capabilities. These widgets often coexist in different tabs or layouts, serving different interaction needs for the same schedule data.
+
+**Multi-Gantt**: When you need to visualize multiple schedules together (such as a portfolio view across projects), the Multi-Gantt widget handles aggregation. Single Gantt Link is specifically scoped to one schedule, making it simpler but less flexible for cross-project views.
+
+### Complementary Widgets
+
+**Layout Tabs Widget**: Single Gantt Link works well alongside Layout Tabs, providing immediate timeline context on the overview while tabs offer navigation to the full Gantt, board view, or other specialized layouts. Users see the preview first and can expand or switch tabs as needed.
+
+**Attribute Widgets**: Overview layouts typically pair the timeline preview with key attribute displays (status, dates, owner) to give users a complete picture without requiring navigation.
+
+## Layout Context
+
+The Single Gantt Link typically appears on schedule default layouts as a visual centerpiece, positioned after status information and summary attributes but before navigation elements like tabs. This placement supports a progressive disclosure pattern:
+
+1. Quick facts (attributes, status indicators)
+2. Visual timeline preview (this widget)
+3. Navigation to detailed views (tabs, links)
+
+This arrangement lets users get immediate visual context while making deeper exploration easily accessible.
+
+## Data Model Context
+
+The widget visualizes the task hierarchy within a schedule. Schedules contain activities (which can nest into sub-tasks) and milestones, all rendered as timeline elements. The hierarchical structure appears in the Gantt's vertical organization, while temporal relationships (start dates, durations, deadlines) drive the horizontal positioning.

package/dist/widget-specifications/cf.projektplanung.singleGanttLink/_summary.md

@@ -0,0 +1 @@
+A button that opens a Gantt chart in a new browser tab. Use on overview pages to show a quick visual sense of the schedule without the overhead of a full Gantt interface.

package/dist/widget-specifications/de.2lforge.curves.widget/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "de.2lforge.curves.widget",
+  "Description": null,
+  "Localized Name": "{\"en\":\"Curves\",\"de\":\"Curves\"}",
+  "Icon": "cf-widget",
+  "Plugin": "de.toolforge.curves",
+  "App": "de.toolforge.curves",
+  "Localized App Name": "{\"en\":\"2lf CURVES App\",\"de\":\"2lf CURVES App\"}",
+  "Repository": "cplace-2lforge-curves",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/de.2lforge.curves.widget/_meta.json

@@ -0,0 +1,12 @@
+{
+  "tags": [
+    "time-series",
+    "chart",
+    "table",
+    "inline-edit",
+    "scheduling",
+    "searchable",
+    "filterable"
+  ],
+  "requiredApp": "de.toolforge.curves"
+}

package/dist/widget-specifications/de.2lforge.curves.widget/_overview.md

@@ -0,0 +1,73 @@
+## Overview
+
+The Curves widget is a comprehensive solution for time-based resource planning and capacity visualization. It displays numeric values distributed across time intervals for multiple entities simultaneously, combining an interactive table with synchronized charts for the same data. The widget enables users to view, analyze, and directly edit time-bound numeric data with support for flexible interval configurations (days, weeks, months, quarters, years, or custom dynamic intervals).
+
+## Use Cases
+
+### Resource Capacity Planning
+Track team member availability across weeks or months, visualize allocation percentages over time, and identify over-allocation or gaps in resource coverage.
+
+### Project Workload Visualization
+Display project effort distribution across time, compare planned vs. actual effort by time period, and aggregate workload across multiple projects or teams.
+
+### Financial Planning and Budgeting
+Track budget allocation across fiscal quarters, visualize cost distribution over project timeline, and monitor cumulative spending patterns.
+
+### Multi-Type Time-Series Comparison
+Compare different metrics (effort, cost, FTE) side-by-side, analyze multiple entity types with distinct visualizations, and stack or layer different data series in charts.
+
+### Hierarchical Reporting
+Group data by custom hierarchies (departments, categories, etc.), display aggregated sums at different hierarchy levels, and filter and focus on specific hierarchy branches.
+
+## Operating Modes
+
+### Dual View Mode
+The widget simultaneously displays data in two synchronized views: an interactive table (Handsontable) for detailed data manipulation and charts (Highcharts) for visual trend analysis. Users can edit values directly in the table when permissions allow, with changes reflected in real-time.
+
+### Table-Only Mode
+Configure the widget to display only the table view by setting the chart type to `NONE`, useful when detailed numeric values are more important than visual trends.
+
+## Data Patterns
+
+### Interval-Based Data
+Works with pages that have start/end date attributes and a numeric value attribute. For example, tasks with start date, end date, and effort/cost values.
+
+### Time-Bounded Resources
+Supports pages with special time-bounded attributes that store values for specific date ranges, enabling more advanced patterns for fine-grained temporal data.
+
+## Design Considerations
+
+### When to Use This Widget
+Choose the Curves widget when you need to:
+- Visualize how numeric values are distributed across time periods
+- Enable users to directly edit time-based allocations
+- Compare multiple entities or types in a unified view
+- See both detailed data (table) and trends (charts) simultaneously
+- Work with configurable time granularity (from days to years)
+- Aggregate and sum data across multiple dimensions
+
+### Time Configuration Flexibility
+The widget supports both absolute dates (fixed start/end) and relative dates (e.g., last 3 months, next 6 weeks). Time intervals can be standard periods (day, week, month, quarter, year) or custom dynamic intervals defined by another search.
+
+### Multiple Type Configurations
+Configure multiple type configurations simultaneously to display different entity types or metrics in the same view, each with its own visualization style, color, and aggregation settings.
+
+### Hierarchical Grouping
+Enable grouping by attribute values (enum values, references, or other attributes) to create hierarchical structure in the table with aggregated sums at each hierarchy level.
+
+## Common Pitfalls
+
+- **Insufficient Time Range**: Ensure the configured date range is appropriate for the interval type. Very short date ranges with large intervals (e.g., 2 weeks with monthly intervals) may result in minimal data display.
+- **Missing Type Configuration**: At least one type configuration must be selected for the widget to be functional.
+- **Dynamic Interval Configuration**: When using dynamic intervals, both the dynamic interval search and attribute must be properly configured.
+- **Permission Requirements**: In-place editing only works when users have appropriate permissions on the entities being displayed.
+
+## Related Widgets
+
+The Curves widget can connect to table widgets for selection synchronization and supports external page provider widgets for dynamic data sources. It publishes events for data changes and responds to table selection events, enabling master-detail patterns.
+
+## Related Patterns
+
+- **Connected Selection**: Link the Curves widget to a table widget to synchronize selections and filter displayed data based on user selection.
+- **Dynamic Intervals**: Instead of fixed periods, define custom intervals from milestone or phase pages for irregular time periods that match project structure.
+- **Target Range Overlay**: Define min/max target values to create a color-coded range band on charts, helping identify over/under-capacity situations.

package/dist/widget-specifications/de.2lforge.curves.widget/_summary.md

@@ -0,0 +1 @@
+A time-series data visualization and planning widget that displays resource allocation, workload, or numeric values across configurable time intervals in both tabular and chart formats. Use for capacity planning, resource management, and temporal data analysis with support for hierarchical grouping and in-place editing.

package/dist/widget-specifications/de.2lforge.toolbar.datePickerWidget/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "de.2lforge.toolbar.datePickerWidget",
+  "Description": null,
+  "Localized Name": "{\"en\":\"datePickerWidget\",\"de\":\"datePickerWidget\"}",
+  "Icon": "cf-widget",
+  "Plugin": "de.toolforge.toolbar",
+  "App": "de.toolforge.toolbar",
+  "Localized App Name": "{\"en\":\"ToolbarApp\",\"de\":\"ToolbarApp\"}",
+  "Repository": "cplace-2lforge-toolbar",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/de.2lforge.toolbar.datePickerWidget/_meta.json

@@ -0,0 +1,9 @@
+{
+  "tags": [
+    "form",
+    "filterable",
+    "detail-view",
+    "time-series"
+  ],
+  "requiredApp": "de.toolforge.toolbar"
+}

package/dist/widget-specifications/de.2lforge.toolbar.datePickerWidget/_overview.md

@@ -0,0 +1,67 @@
+## Overview
+
+The Date Picker Widget provides a reusable, toolbar-integrated date picker component that allows users to select a single date through an interactive calendar interface. When clicked, the toolbar button opens a dropdown containing a calendar based on bootstrap-datepicker, with optional quick selection shortcuts for dates relative to today.
+
+The widget provides visual state indicators showing whether the date has been changed from the default value and displays validation errors for invalid dates. A reset capability allows users to quickly return to the default value with one click.
+
+## Use Cases
+
+### Date Selection in Reports and Filters
+When users need to filter data by a specific date or generate reports for a particular day:
+- Selecting a report generation date
+- Filtering project milestones by date
+- Setting a deadline or due date
+- Choosing a start date for an analysis period
+
+### Quick Date Navigation
+When users frequently need to select dates relative to today without clicking through calendar months:
+- Selecting "10 days from now" for follow-up tasks
+- Choosing "yesterday" for daily reports
+- Setting "30 days ago" as a lookback period start
+- Quick selection of dates like "100 days from today" for long-term planning
+
+### Date Input in Custom Pages
+When building custom pages that require date input as part of a form or configuration interface:
+- Configuration dialogs requiring date parameters
+- Custom workflow forms with date fields
+- Dashboard filters with date selection
+
+### Default Date with User Override
+When a default date should be suggested but users need the ability to change it easily:
+- Forms pre-filled with "today" that can be adjusted
+- Date fields with calculated defaults (e.g., project end date based on duration)
+- Reset functionality to quickly return to the default value
+
+## Design Considerations
+
+### When to Use This Widget
+- You need a single date selection in a toolbar or form
+- A calendar interface improves usability over text input
+- You want visual feedback for changed/invalid states
+- Users benefit from relative date shortcuts
+
+### Technical Considerations
+- All dates are normalized to midnight local time
+- Built-in validation for Date objects (null or valid Date only)
+- Widget tracks changes from default and allows reset
+- Date restrictions in picker options may not work correctly with relative date buttons
+- Only single date selection is supported (multidate not available)
+
+## Common Pitfalls
+
+- Using date restriction options (like startDate or daysOfWeekDisabled) in combination with relative date shortcuts - these are not fully compatible
+- Expecting multidate selection support - this widget only supports single date selection
+- Not accounting for timezone normalization - dates are stored at midnight local time
+
+## Alternatives
+
+| Alternative | When to Use |
+|-------------|-------------|
+| `tlf-date-range-picker` | When you need to select a date range (start and end dates) instead of a single date |
+| `tlf-date-picker-core` | When you need just the calendar without toolbar button styling |
+| `tlf-date-diff` | When you only need relative date selection without the calendar interface |
+
+## Related Patterns
+
+- **Toolbar Widget Family**: This widget is part of the 2lforge Toolbar plugin alongside DropDownWidget and MiscWidget
+- **Date Range Selection**: For selecting date ranges, use the sibling component tlf-date-range-picker

package/dist/widget-specifications/de.2lforge.toolbar.datePickerWidget/_summary.md

@@ -0,0 +1 @@
+A toolbar button widget that displays a calendar-based date picker with optional relative date shortcuts, enabling users to select single dates through an interactive dropdown interface.

package/dist/widget-specifications/de.2lforge.toolbar.dropDownWidget/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "de.2lforge.toolbar.dropDownWidget",
+  "Description": null,
+  "Localized Name": "{\"en\":\"dropDownWidget\",\"de\":\"dropDownWidget\"}",
+  "Icon": "cf-widget",
+  "Plugin": "de.toolforge.toolbar",
+  "App": "de.toolforge.toolbar",
+  "Localized App Name": "{\"en\":\"ToolbarApp\",\"de\":\"ToolbarApp\"}",
+  "Repository": "cplace-2lforge-toolbar",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/de.2lforge.toolbar.dropDownWidget/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "form",
+    "filterable",
+    "searchable",
+    "drag-drop",
+    "selectable"
+  ],
+  "requiredApp": "de.toolforge.toolbar"
+}