@ngxtm/devkit 3.15.0 → 3.17.0

package/skills/graphql-architect/SKILL.md

@@ -1,182 +1,97 @@
 ---
 name: graphql-architect
-description: Master modern GraphQL with federation, performance optimization,
-  and enterprise security. Build scalable schemas, implement advanced caching,
-  and design real-time systems. Use PROACTIVELY for GraphQL architecture or
-  performance optimization.
-metadata:
-  model: opus
+description: Use when designing GraphQL schemas, implementing Apollo Federation, or building real-time subscriptions. Invoke for schema design, resolvers with DataLoader, query optimization, federation directives.
+triggers:
+  - GraphQL
+  - Apollo Federation
+  - GraphQL schema
+  - API graph
+  - GraphQL subscriptions
+  - Apollo Server
+  - schema design
+  - GraphQL resolvers
+  - DataLoader
+role: architect
+scope: design
+output-format: schema
 ---
 
-## Use this skill when
+# GraphQL Architect
 
-- Working on graphql architect tasks or workflows
-- Needing guidance, best practices, or checklists for graphql architect
+Senior GraphQL architect specializing in schema design and distributed graph architectures with deep expertise in Apollo Federation 2.5+, GraphQL subscriptions, and performance optimization.
 
-## Do not use this skill when
+## Role Definition
 
-- The task is unrelated to graphql architect
-- You need a different domain or tool outside this scope
+You are a senior GraphQL architect with 10+ years of API design experience. You specialize in Apollo Federation, schema-first design, and building type-safe API graphs that scale across teams and services. You master resolvers, DataLoader patterns, and real-time subscriptions.
 
-## Instructions
+## When to Use This Skill
 
-- Clarify goals, constraints, and required inputs.
-- Apply relevant best practices and validate outcomes.
-- Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
+- Designing GraphQL schemas and type systems
+- Implementing Apollo Federation architectures
+- Building resolvers with DataLoader optimization
+- Creating real-time GraphQL subscriptions
+- Optimizing query complexity and performance
+- Setting up authentication and authorization
 
-You are an expert GraphQL architect specializing in enterprise-scale schema design, federation, performance optimization, and modern GraphQL development patterns.
+## Core Workflow
 
-## Purpose
+1. **Domain Modeling** - Map business domains to GraphQL type system
+2. **Design Schema** - Create types, interfaces, unions with federation directives
+3. **Implement Resolvers** - Write efficient resolvers with DataLoader patterns
+4. **Secure** - Add query complexity limits, depth limiting, field-level auth
+5. **Optimize** - Performance tune with caching, persisted queries, monitoring
 
-Expert GraphQL architect focused on building scalable, performant, and secure GraphQL systems for enterprise applications. Masters modern federation patterns, advanced optimization techniques, and cutting-edge GraphQL tooling to deliver high-performance APIs that scale with business needs.
-
-## Capabilities
+## Reference Guide
 
-### Modern GraphQL Federation and Architecture
+Load detailed guidance based on context:
 
-- Apollo Federation v2 and Subgraph design patterns
-- GraphQL Fusion and composite schema implementations
-- Schema composition and gateway configuration
-- Cross-team collaboration and schema evolution strategies
-- Distributed GraphQL architecture patterns
-- Microservices integration with GraphQL federation
-- Schema registry and governance implementation
-
-### Advanced Schema Design and Modeling
-
-- Schema-first development with SDL and code generation
-- Interface and union type design for flexible APIs
-- Abstract types and polymorphic query patterns
-- Relay specification compliance and connection patterns
-- Schema versioning and evolution strategies
-- Input validation and custom scalar types
-- Schema documentation and annotation best practices
-
-### Performance Optimization and Caching
-
-- DataLoader pattern implementation for N+1 problem resolution
-- Advanced caching strategies with Redis and CDN integration
-- Query complexity analysis and depth limiting
-- Automatic persisted queries (APQ) implementation
-- Response caching at field and query levels
-- Batch processing and request deduplication
-- Performance monitoring and query analytics
-
-### Security and Authorization
-
-- Field-level authorization and access control
-- JWT integration and token validation
-- Role-based access control (RBAC) implementation
-- Rate limiting and query cost analysis
-- Introspection security and production hardening
-- Input sanitization and injection prevention
-- CORS configuration and security headers
-
-### Real-Time Features and Subscriptions
-
-- GraphQL subscriptions with WebSocket and Server-Sent Events
-- Real-time data synchronization and live queries
-- Event-driven architecture integration
-- Subscription filtering and authorization
-- Scalable subscription infrastructure design
-- Live query implementation and optimization
-- Real-time analytics and monitoring
-
-### Developer Experience and Tooling
-
-- GraphQL Playground and GraphiQL customization
-- Code generation and type-safe client development
-- Schema linting and validation automation
-- Development server setup and hot reloading
-- Testing strategies for GraphQL APIs
-- Documentation generation and interactive exploration
-- IDE integration and developer tooling
-
-### Enterprise Integration Patterns
-
-- REST API to GraphQL migration strategies
-- Database integration with efficient query patterns
-- Microservices orchestration through GraphQL
-- Legacy system integration and data transformation
-- Event sourcing and CQRS pattern implementation
-- API gateway integration and hybrid approaches
-- Third-party service integration and aggregation
-
-### Modern GraphQL Tools and Frameworks
-
-- Apollo Server, Apollo Federation, and Apollo Studio
-- GraphQL Yoga, Pothos, and Nexus schema builders
-- Prisma and TypeGraphQL integration
-- Hasura and PostGraphile for database-first approaches
-- GraphQL Code Generator and schema tooling
-- Relay Modern and Apollo Client optimization
-- GraphQL mesh for API aggregation
-
-### Query Optimization and Analysis
-
-- Query parsing and validation optimization
-- Execution plan analysis and resolver tracing
-- Automatic query optimization and field selection
-- Query whitelisting and persisted query strategies
-- Schema usage analytics and field deprecation
-- Performance profiling and bottleneck identification
-- Caching invalidation and dependency tracking
-
-### Testing and Quality Assurance
-
-- Unit testing for resolvers and schema validation
-- Integration testing with test client frameworks
-- Schema testing and breaking change detection
-- Load testing and performance benchmarking
-- Security testing and vulnerability assessment
-- Contract testing between services
-- Mutation testing for resolver logic
-
-## Behavioral Traits
-
-- Designs schemas with long-term evolution in mind
-- Prioritizes developer experience and type safety
-- Implements robust error handling and meaningful error messages
-- Focuses on performance and scalability from the start
-- Follows GraphQL best practices and specification compliance
-- Considers caching implications in schema design decisions
-- Implements comprehensive monitoring and observability
-- Balances flexibility with performance constraints
-- Advocates for schema governance and consistency
-- Stays current with GraphQL ecosystem developments
-
-## Knowledge Base
-
-- GraphQL specification and best practices
-- Modern federation patterns and tools
-- Performance optimization techniques and caching strategies
-- Security considerations and enterprise requirements
-- Real-time systems and subscription architectures
-- Database integration patterns and optimization
-- Testing methodologies and quality assurance practices
-- Developer tooling and ecosystem landscape
-- Microservices architecture and API design patterns
-- Cloud deployment and scaling strategies
-
-## Response Approach
-
-1. **Analyze business requirements** and data relationships
-2. **Design scalable schema** with appropriate type system
-3. **Implement efficient resolvers** with performance optimization
-4. **Configure caching and security** for production readiness
-5. **Set up monitoring and analytics** for operational insights
-6. **Design federation strategy** for distributed teams
-7. **Implement testing and validation** for quality assurance
-8. **Plan for evolution** and backward compatibility
-
-## Example Interactions
-
-- "Design a federated GraphQL architecture for a multi-team e-commerce platform"
-- "Optimize this GraphQL schema to eliminate N+1 queries and improve performance"
-- "Implement real-time subscriptions for a collaborative application with proper authorization"
-- "Create a migration strategy from REST to GraphQL with backward compatibility"
-- "Build a GraphQL gateway that aggregates data from multiple microservices"
-- "Design field-level caching strategy for a high-traffic GraphQL API"
-- "Implement query complexity analysis and rate limiting for production safety"
-- "Create a schema evolution strategy that supports multiple client versions"
+| Topic | Reference | Load When |
+|-------|-----------|-----------|
+| Schema Design | `references/schema-design.md` | Types, interfaces, unions, enums, input types |
+| Resolvers | `references/resolvers.md` | Resolver patterns, context, DataLoader, N+1 |
+| Federation | `references/federation.md` | Apollo Federation, subgraphs, entities, directives |
+| Subscriptions | `references/subscriptions.md` | Real-time updates, WebSocket, pub/sub patterns |
+| Security | `references/security.md` | Query depth, complexity analysis, authentication |
+| REST Migration | `references/migration-from-rest.md` | Migrating REST APIs to GraphQL |
+
+## Constraints
+
+### MUST DO
+- Use schema-first design approach
+- Implement proper nullable field patterns
+- Use DataLoader for batching and caching
+- Add query complexity analysis
+- Document all types and fields
+- Follow GraphQL naming conventions (camelCase)
+- Use federation directives correctly
+- Provide example queries for all operations
+
+### MUST NOT DO
+- Create N+1 query problems
+- Skip query depth limiting
+- Expose internal implementation details
+- Use REST patterns in GraphQL
+- Return null for non-nullable fields
+- Skip error handling in resolvers
+- Hardcode authorization logic
+- Ignore schema validation
+
+## Output Templates
+
+When implementing GraphQL features, provide:
+1. Schema definition (SDL with types and directives)
+2. Resolver implementation (with DataLoader patterns)
+3. Query/mutation/subscription examples
+4. Brief explanation of design decisions
+
+## Knowledge Reference
+
+Apollo Server, Apollo Federation 2.5+, GraphQL SDL, DataLoader, GraphQL Subscriptions, WebSocket, Redis pub/sub, schema composition, query complexity, persisted queries, schema stitching, type generation
+
+## Related Skills
+
+- **Backend Developer** - Resolver implementation and data access
+- **API Designer** - REST-to-GraphQL migration strategies
+- **Microservices Architect** - Service boundary definition
+- **Frontend Developer** - Client query optimization
+- **Database Optimizer** - Query efficiency and N+1 prevention

package/skills/haskell-pro/SKILL.md

@@ -5,6 +5,8 @@ description: Expert Haskell engineer specializing in advanced type systems, pure
   type-level programming, concurrency, and architecture guidance.
 metadata:
   model: sonnet
+risk: unknown
+source: community
 ---
 
 ## Use this skill when

package/skills/helm-chart-scaffolding/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: helm-chart-scaffolding
-description: Design, organize, and manage Helm charts for templating and packaging Kubernetes applications with reusable configurations. Use when creating Helm charts, packaging Kubernetes applications, or implementing templated deployments.
+description: "Design, organize, and manage Helm charts for templating and packaging Kubernetes applications with reusable configurations. Use when creating Helm charts, packaging Kubernetes applications, or impl..."
+risk: unknown
+source: community
 ---
 
 # Helm Chart Scaffolding

package/skills/helpdesk-automation/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: helpdesk-automation
+description: "Automate HelpDesk tasks via Rube MCP (Composio): list tickets, manage views, use canned responses, and configure custom fields. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+risk: unknown
+source: community
+---
+
+# HelpDesk Automation via Rube MCP
+
+Automate HelpDesk ticketing operations through Composio's HelpDesk toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active HelpDesk connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `helpdesk`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `helpdesk`
+3. If connection is not ACTIVE, follow the returned auth link to complete HelpDesk authentication
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. List and Browse Tickets
+
+**When to use**: User wants to retrieve, browse, or paginate through support tickets
+
+**Tool sequence**:
+1. `HELPDESK_LIST_TICKETS` - List tickets with sorting and pagination [Required]
+
+**Key parameters**:
+- `silo`: Ticket folder - 'tickets', 'archive', 'trash', or 'spam' (default: 'tickets')
+- `sortBy`: Sort field - 'createdAt', 'updatedAt', or 'lastMessageAt' (default: 'createdAt')
+- `order`: Sort direction - 'asc' or 'desc' (default: 'desc')
+- `pageSize`: Results per page, 1-100 (default: 20)
+- `next.value`: Timestamp cursor for forward pagination
+- `next.ID`: ID cursor for forward pagination
+- `prev.value`: Timestamp cursor for backward pagination
+- `prev.ID`: ID cursor for backward pagination
+
+**Pitfalls**:
+- Pagination uses cursor-based approach with timestamp + ID pairs
+- Forward pagination requires both `next.value` and `next.ID` from previous response
+- Backward pagination requires both `prev.value` and `prev.ID`
+- `silo` determines which folder to list from; default is active tickets
+- `pageSize` max is 100; default is 20
+- Archived and trashed tickets are in separate silos
+
+### 2. Manage Ticket Views
+
+**When to use**: User wants to see saved agent views for organizing tickets
+
+**Tool sequence**:
+1. `HELPDESK_LIST_VIEWS` - List all agent views [Required]
+
+**Key parameters**: (none required)
+
+**Pitfalls**:
+- Views are predefined saved filters configured by agents in the HelpDesk UI
+- View definitions include filter criteria that can be used to understand ticket organization
+- Views cannot be created or modified via API; they are managed in the HelpDesk UI
+
+### 3. Use Canned Responses
+
+**When to use**: User wants to list available canned (template) responses for tickets
+
+**Tool sequence**:
+1. `HELPDESK_LIST_CANNED_RESPONSES` - Retrieve all predefined reply templates [Required]
+
+**Key parameters**: (none required)
+
+**Pitfalls**:
+- Canned responses are predefined templates for common replies
+- They may include placeholder variables that need to be filled in
+- Canned responses are managed through the HelpDesk UI
+- Response content may include HTML formatting
+
+### 4. Inspect Custom Fields
+
+**When to use**: User wants to view custom field definitions for the account
+
+**Tool sequence**:
+1. `HELPDESK_LIST_CUSTOM_FIELDS` - List all custom field definitions [Required]
+
+**Key parameters**: (none required)
+
+**Pitfalls**:
+- Custom fields extend the default ticket schema with organization-specific data
+- Field definitions include field type, name, and validation rules
+- Custom fields are configured in the HelpDesk admin panel
+- Field values appear on tickets when the field has been populated
+
+## Common Patterns
+
+### Ticket Browsing Pattern
+
+```
+1. Call HELPDESK_LIST_TICKETS with desired silo and sortBy
+2. Process the returned page of tickets
+3. Extract next.value and next.ID from the response
+4. Call HELPDESK_LIST_TICKETS with those cursor values for next page
+5. Continue until no more cursor values are returned
+```
+
+### Ticket Folder Navigation
+
+```
+Active tickets:  silo='tickets'
+Archived:        silo='archive'
+Trashed:         silo='trash'
+Spam:            silo='spam'
+```
+
+### Cursor-Based Pagination
+
+```
+Forward pagination:
+  - Use next.value (timestamp) and next.ID from response
+  - Pass as next.value and next.ID parameters in next call
+
+Backward pagination:
+  - Use prev.value (timestamp) and prev.ID from response
+  - Pass as prev.value and prev.ID parameters in next call
+```
+
+## Known Pitfalls
+
+**Cursor Pagination**:
+- Both timestamp and ID are required for cursor navigation
+- Cursor values are timestamps in ISO 8601 date-time format
+- Mixing forward and backward cursors in the same request is undefined behavior
+
+**Silo Filtering**:
+- Tickets are physically separated into silos (folders)
+- Moving tickets between silos is done in the HelpDesk UI
+- Each silo query is independent; there is no cross-silo search
+
+**Read-Only Operations**:
+- Current Composio toolkit provides list/read operations
+- Ticket creation, update, and reply operations may require additional tools
+- Check RUBE_SEARCH_TOOLS for any newly available tools
+
+**Rate Limits**:
+- HelpDesk API has per-account rate limits
+- Implement backoff on 429 responses
+- Keep page sizes reasonable to avoid timeouts
+
+**Response Parsing**:
+- Response data may be nested under `data` or `data.data`
+- Parse defensively with fallback patterns
+- Ticket IDs are strings
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| List tickets | HELPDESK_LIST_TICKETS | silo, sortBy, order, pageSize |
+| List views | HELPDESK_LIST_VIEWS | (none) |
+| List canned responses | HELPDESK_LIST_CANNED_RESPONSES | (none) |
+| List custom fields | HELPDESK_LIST_CUSTOM_FIELDS | (none) |
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.

package/skills/hig-components-content/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: hig-components-content
+version: 1.0.0
+description: ">"
+  Apple Human Interface Guidelines for content display components. Use this skill when the user asks about
+  "charts component", "collection view", "image view", "web view", "color well", "image well",
+  "activity view", "lockup", "data visualization", "content display", displaying images, rendering
+  web content, color pickers, or presenting collections of items in Apple apps.
+  Also use when the user says "how should I display charts", "what's the best way to show images",
+  "should I use a web view", "how do I build a grid of items", "what component shows media",
+  or "how do I present a share sheet".
+  Cross-references: hig-foundations for color/typography/accessibility, hig-patterns for data
+  visualization patterns, hig-components-layout for structural containers, hig-platforms for
+  platform-specific component behavior.
+risk: unknown
+source: community
+---
+
+# Apple HIG: Content Components
+
+Check for `.claude/apple-design-context.md` before asking questions. Use existing context and only ask for information not already covered.
+
+## Key Principles
+
+1. **Adapt to different sizes and contexts.** Content components must work across screen sizes, orientations, and multitasking configurations. Use Auto Layout and size classes.
+
+2. **Make content accessible.** Charts need audio graph support. Images need alt text. Collections need proper VoiceOver navigation order. All content components need labels and descriptions.
+
+3. **Maintain visual hierarchy.** Use spacing, sizing, and grouping to establish clear information hierarchy. Primary content should be visually prominent.
+
+4. **Use system components first.** Evaluate UICollectionView, SwiftUI Charts, WKWebView before building custom. System components come with built-in accessibility and platform adaptation.
+
+5. **Respect platform conventions.** A collection on tvOS uses large lockups with parallax. The same collection on iOS uses compact cells with touch targets. On visionOS, content gains depth and hover effects.
+
+6. **Handle empty states.** Show a meaningful empty state with guidance on how to populate it, not a blank screen.
+
+7. **Optimize for performance.** Use lazy loading, cell reuse, pagination, and prefetching for large datasets.
+
+## Reference Index
+
+| Reference | Topic | Key content |
+|---|---|---|
+| [charts.md](references/charts.md) | Charts | Swift Charts, bar/line/area/point marks, chart accessibility, audio graphs |
+| [collections.md](references/collections.md) | Collections | Grid/list layouts, compositional layout, selection, reordering, diffable data sources |
+| [image-views.md](references/image-views.md) | Image Views | Aspect ratio handling, content modes, SF Symbol images, accessibility |
+| [image-wells.md](references/image-wells.md) | Image Wells | Drag-and-drop image selection, macOS-specific, placeholder content |
+| [color-wells.md](references/color-wells.md) | Color Wells | Color selection UI, system color picker, custom color spaces |
+| [web-views.md](references/web-views.md) | Web Views | WKWebView, SFSafariViewController, navigation controls, content restrictions |
+| [activity-views.md](references/activity-views.md) | Activity Views | Share sheets, activity items, custom activities, action extensions |
+| [lockups.md](references/lockups.md) | Lockups | Image+text elements, tvOS card layouts, focus effects, shelf layouts |
+
+## Component Selection Guide
+
+| Content Need | Recommended Component | Platform Notes |
+|---|---|---|
+| Visualizing quantitative data | Charts (Swift Charts) | iOS 16+, macOS 13+, watchOS 9+ |
+| Browsing a grid or list of items | Collection View | Compositional layout for complex arrangements |
+| Displaying a single image | Image View | Support aspect ratio fitting; provide accessibility description |
+| Selecting an image via drag or browse | Image Well | macOS primarily; use image pickers on iOS |
+| Selecting a color | Color Well | Triggers system color picker; macOS, iOS 14+ |
+| Showing web content inline | Web View (WKWebView) | Use SFSafariViewController for external browsing |
+| Sharing content to other apps | Activity View | System share sheet with configurable activity types |
+| Content card (image + text) | Lockup | Primarily tvOS; adaptable to other platforms |
+
+## Output Format
+
+1. **Component recommendation with rationale**, referencing the relevant HIG reference file.
+2. **Configuration guidance** -- key properties and setup.
+3. **Accessibility requirements** for the recommended component.
+4. **Platform-specific notes** for targeted platforms.
+
+## Questions to Ask
+
+1. What type of content? (Quantitative data, images, web content, browsable collection, share action?)
+2. Which platforms?
+3. Static or dynamic content?
+4. How much content? (Few items vs hundreds/thousands affects component choice and optimization.)
+
+## Related Skills
+
+- **hig-foundations** -- Color, typography, accessibility, and image guidelines
+- **hig-patterns** -- Data visualization, sharing, and loading patterns
+- **hig-components-layout** -- Structural containers (scroll views, lists, split views) hosting content
+- **hig-platforms** -- Platform-specific component behavior (lockups on tvOS, web views on macOS)
+
+---
+
+*Built by [Raintree Technology](https://raintree.technology) · [More developer tools](https://raintree.technology)*
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.

package/skills/hig-components-content/references/activity-views.md

@@ -0,0 +1,79 @@
+---
+title: "Activity views | Apple Developer Documentation"
+source: https://developer.apple.com/design/human-interface-guidelines/activity-views
+
+# Activity views
+
+An activity view — often called a _share sheet_ — presents a range of tasks that people can perform in the current context.
+
+![A stylized representation of an activity view or share sheet. The image is tinted red to subtly reflect the red in the original six-color Apple logo.](https://docs-assets.developer.apple.com/published/74899abd7c2a017fc05523d112743616/components-activity-view-intro%402x.png)
+
+Activity views present sharing activities like messaging and actions like Copy and Print, in addition to quick access to frequently used apps. People typically reveal a share sheet by choosing an Action button while viewing a page or document, or after they’ve selected an item. An activity view can appear as a sheet or a popover, depending on the device and orientation.
+
+You can provide app-specific activities that can appear in a share sheet when people open it within your app or game. For example, Photos provides app-specific actions like Copy Photo, Add to Album, and Adjust Location. By default, the system lists app-specific actions before actions — such as Add to Files or AirPlay — that are available in multiple apps or throughout the system. People can edit the list of actions to ensure that it displays the ones they use most and to add new ones.
+
+You can also create app extensions to provide custom share and action activities that people can use in other apps. (An _app extension_ is code you provide that people can install and use outside of your app.) For example, you might create a custom share activity that people can install to help them share a webpage with a specific social media service. Even though macOS doesn’t provide an activity view, you can create share and action app extensions that people can use on a Mac. For guidance, see [Share and action extensions](https://developer.apple.com/design/human-interface-guidelines/activity-views#Share-and-action-extensions).
+
+## [Best practices](https://developer.apple.com/design/human-interface-guidelines/activity-views#Best-practices)
+
+**Avoid creating duplicate versions of common actions that are already available in the activity view.** For example, providing a duplicate Print action is unnecessary and confusing because people wouldn’t know how to distinguish your action from the system-provided one. If you need to provide app-specific functionality that’s similar to an existing action, give it a custom title. For example, if you let people use custom formatting to print a bank transaction, use a title that helps people understand what your print activity does, like “Print Transaction.”
+
+**Consider using a symbol to represent your custom activity.** [SF Symbols](https://developer.apple.com/design/human-interface-guidelines/sf-symbols) provides a comprehensive set of configurable symbols you can use to communicate items and concepts in an activity view. If you need to create a custom interface icon, center it in an area measuring about 70x70 pixels. For guidance, see [Icons](https://developer.apple.com/design/human-interface-guidelines/icons).
+
+**Write a succinct, descriptive title for each custom action you provide.** If a title is too long, the system wraps it and may truncate it. Prefer a single verb or a brief verb phrase that clearly communicates what the action does. Avoid including your company or product name in an action title. In contrast, the share sheet displays the title of a share activity — typically a company name — below the icon that represents it.
+
+**Make sure activities are appropriate for the current context.** Although you can’t reorder system-provided tasks in an activity view, you can exclude tasks that aren’t applicable to your app. For example, if it doesn’t make sense to print from within your app, you can exclude the Print activity. You can also identify which custom tasks to show at any given time.
+
+**Use the Share button to display an activity view.** People are accustomed to accessing system-provided activities when they choose the Share button. Avoid confusing people by providing an alternative way to do the same thing.
+
+![A screenshot of the Notes app on iPhone, with an open Notes document titled Nature Walks. The top toolbar includes a Share button grouped with a More button on its trailing edge.](https://docs-assets.developer.apple.com/published/5cdc980290422f59da0f79ab5f5efd13/activity-views-share-button%402x.png)
+
+![A screenshot of the Notes app on iPhone, with an open Notes document titled Nature Walks. An activity view is open from the Share button, including controls for sharing the document with contacts or other apps, and copying, exporting, or adding markup to the document.](https://docs-assets.developer.apple.com/published/68a789fa9a70048fcef600615af180fd/activity-views-share-sheet%402x.png)
+
+## [Share and action extensions](https://developer.apple.com/design/human-interface-guidelines/activity-views#Share-and-action-extensions)
+
+Share extensions give people a convenient way to share information from the current context with apps, social media accounts, and other services. Action extensions let people initiate content-specific tasks — like adding a bookmark, copying a link, editing an inline image, or displaying selected text in another language — without leaving the current context.
+
+The system presents share and action extensions differently depending on the platform:
+
+  * In iOS and iPadOS, share and action extensions are displayed in the share sheet that appears when people choose an Action button.
+
+  * In macOS, people access share extensions by clicking a Share button in the toolbar or choosing Share in a context menu. People can access an action extension by holding the pointer over certain types of embedded content — like an image they add to a Mail compose window — clicking a toolbar button, or choosing a quick action in a Finder window.
+
+
+
+
+**If necessary, create a custom interface that feels familiar to people.** For a share extension, prefer the system-provided composition view because it provides a consistent sharing experience that people already know. For an action extension, include your app name. If you need to present an interface, include elements of your app’s interface to help people understand that your extension and your app are related.
+
+**Streamline and limit interaction.** People appreciate extensions that let them perform a task in just a few steps. For example, a share extension might immediately post an image to a social media account with a single tap or click.
+
+**Avoid placing a modal view above your extension.** By default, the system displays an extension within a modal view. While it might be necessary to display an alert above an extension, avoid displaying additional modal views.
+
+**If necessary, provide an image that communicates the purpose of your extension.** A share extension automatically uses your app icon, helping give people confidence that your app provided the extension. For an action extension, prefer using a [symbol](https://developer.apple.com/design/human-interface-guidelines/sf-symbols) or creating an interface [icon](https://developer.apple.com/design/human-interface-guidelines/icons) that clearly identifies the task.
+
+**Use your main app to denote the progress of a lengthy operation.** An activity view dismisses immediately after people complete the task in your share or action extension. If a task is time-consuming, continue it in the background, and give people a way to check the status in your main app. Although you can use a notification to tell people about a problem, don’t notify them simply because the task completes.
+
+## [Platform considerations](https://developer.apple.com/design/human-interface-guidelines/activity-views#Platform-considerations)
+
+ _No additional considerations for iOS, iPadOS, or visionOS. Not supported in macOS, tvOS, or watchOS._
+
+## [Resources](https://developer.apple.com/design/human-interface-guidelines/activity-views#Resources)
+
+#### [Related](https://developer.apple.com/design/human-interface-guidelines/activity-views#Related)
+
+[Sheets](https://developer.apple.com/design/human-interface-guidelines/sheets)
+
+[Popovers](https://developer.apple.com/design/human-interface-guidelines/popovers)
+
+#### [Developer documentation](https://developer.apple.com/design/human-interface-guidelines/activity-views#Developer-documentation)
+
+[`UIActivityViewController`](https://developer.apple.com/documentation/UIKit/UIActivityViewController) — UIKit
+
+[`UIActivity`](https://developer.apple.com/documentation/UIKit/UIActivity) — UIKit
+
+[App Extension Support](https://developer.apple.com/documentation/Foundation/app-extension-support) — Foundation
+
+#### [Videos](https://developer.apple.com/design/human-interface-guidelines/activity-views#Videos)
+
+[![](https://devimages-cdn.apple.com/wwdc-services/images/124/74342B30-92E9-48F3-B0F2-6E42C8FD9391/6506_wide_250x141_1x.jpg) Design for Collaboration with Messages ](https://developer.apple.com/videos/play/wwdc2022/10015)
+