imhcode 1.0.0

package/skills/stripe/SKILL.md

@@ -0,0 +1,168 @@
+---
+name: stripe-ui-skills
+description: Stripe's UI design system. Use when building interfaces inspired by Stripe's aesthetic - light mode, Inter font, 4px grid.
+license: MIT
+metadata:
+  author: design-skills
+  version: "1.0.0"
+  source: https://stripe.com
+---
+
+# Stripe UI Skills
+
+Opinionated constraints for building Stripe-style interfaces with AI agents.
+
+## When to Apply
+
+Reference these guidelines when:
+- Building light-mode interfaces
+- Creating Stripe-inspired design systems
+- Implementing UIs with Inter font and 4px grid
+
+## Colors
+
+- SHOULD use light backgrounds for primary surfaces
+- MUST use `#F2F6F9` as page background (`surface-base`)
+- MUST use `#517BDF` for primary actions and focus states (`accent`)
+- SHOULD reduce color palette (currently 30 colors detected)
+- MUST maintain text contrast ratio of at least 4.5:1 for accessibility
+
+### Semantic Tokens
+
+| Token | HEX | RGB | Usage |
+|-------|-----|-----|-------|
+| `surface-base` | #F2F6F9 | rgb(242,246,249) | Page background |
+| `surface-raised` | #071A34 | rgb(7,26,52) | Cards, modals, raised surfaces |
+| `text-primary` | #9DA1A9 | rgb(157,161,169) | Headings, body text |
+| `text-secondary` | #B1BCC7 | rgb(177,188,199) | Secondary, muted text |
+| `text-tertiary` | #737883 | rgb(115,120,131) | Additional text |
+| `border-default` | #131E2B | rgb(19,30,43) | Subtle borders, dividers |
+| `success` | #75B88A | rgb(117,184,138) | Success states, confirmations |
+| `accent` | #517BDF | rgb(81,123,223) | Primary actions, links, focus |
+| `warning` | #FAE6C2 | rgb(250,230,194) | Warning states, cautions |
+| `destructive` | #D29E79 | rgb(210,158,121) | Error states, delete actions |
+
+## Typography
+
+- MUST use `Inter` as primary font family
+- SHOULD use single font family for consistency
+- MUST use `53px` / `700` for primary headings
+- MUST use `28px` / `semi_bold` for body text
+- SHOULD reduce font weights (currently 5 detected)
+- MUST use `text-balance` for headings and `text-pretty` for body text
+- SHOULD use `tabular-nums` for numeric data
+- NEVER modify letter-spacing unless explicitly requested
+
+### Text Styles
+
+| Style | Font | Size | Weight | Color | Count |
+|-------|------|------|--------|-------|-------|
+| `heading-1` | Inter | 53px | 700 | #18105B | 1 |
+| `body` | Inter | 28px | semi_bold | #242424 | 1 |
+| `body-secondary` | Inter | 27px | semi_bold | #2D2D2D | 1 |
+| `body-secondary` | Inter | 26px | semi_bold | #517BDF | 1 |
+| `text-24px` | Inter | 24px | semi_bold | #EBD6F3 | 1 |
+| `text-18px` | Inter | 18px | 500 | #E76874 | 1 |
+| `text-18px` | Inter | 18px | semi_bold | #2D2D2D | 1 |
+| `text-18px` | Inter | 18px | semi_bold | #3E3D3D | 1 |
+| `text-16px` | Inter | 16px | 400 | #F6CFB7 | 1 |
+| `text-15px` | Inter | 15px | 400 | #626870 | 1 |
+
+### Typography Reference
+
+**Font Families:**
+- `Inter` (used 62x)
+
+**Font Sizes:** 5px, 6px, 7px, 8px, 9px, 10px, 11px, 12px, 13px, 14px, 15px, 16px, 18px, 24px, 26px, 27px, 28px, 53px
+
+## Spacing
+
+- MUST use 4px grid for spacing
+- SHOULD use spacing from scale: 1px, 2px, 3px, 4px, 5px, 11px, 12px, 13px
+- SHOULD use 5px as default gap between elements
+- NEVER use arbitrary spacing values (use design scale)
+- SHOULD maintain consistent padding within containers
+
+## Borders
+
+- MUST use border-radius from scale: 3px, 4px, 7px, 15px, 22px, 33px, 35px
+- SHOULD use 22px+ radius for pill-shaped elements
+- SHOULD limit border widths to: 1px, 2px, 3px
+- SHOULD use 22px as default border-radius
+- NEVER use arbitrary border-radius values (use design scale)
+- SHOULD use subtle borders (1px) for element separation
+
+### Border Radius Reference
+
+**Scale:** 3px, 4px, 7px, 15px, 22px, 33px, 35px
+
+## Layout
+
+- MUST design for 1920px base viewport width
+- SHOULD use consistent element widths: 10px, 227px, 7px, 30px, 17px
+- SHOULD maintain text-heavy layout with clear hierarchy
+- NEVER use `h-screen`, use `h-dvh` for full viewport height
+- MUST respect `safe-area-inset` for fixed elements
+- SHOULD use `size-*` for square elements instead of `w-*` + `h-*`
+
+### Detected Layout Patterns
+
+- **Main Content**: width: 1920px, height: 1080px
+- **Main Content**: width: 1920px, height: 1045px
+- **Header**: height: 69px
+
+## Components
+
+- MUST use `0px` height for input fields
+
+### Buttons
+
+| Variant | Background | Text | Border | Height | Radius |
+|---------|------------|------|--------|--------|--------|
+| Ghost | transparent | #737883 | none | - | - |
+
+### Inputs
+
+- Height: `0px`
+
+## Interactive States
+
+### Focus
+
+- MUST use `2px` outline with accent color (`#517BDF`)
+- MUST use `2px` outline-offset
+- NEVER remove focus indicators
+
+### Hover
+
+- Buttons (primary): lighten background by 10%
+- Buttons (secondary): use `#071A34` background
+- List items: use `#071A34` background
+
+### Disabled
+
+- MUST use `opacity: 0.5`
+- MUST use `cursor: not-allowed`
+
+## Interaction
+
+- MUST use an `AlertDialog` for destructive or irreversible actions
+- SHOULD use structural skeletons for loading states
+- MUST show errors next to where the action happens
+- NEVER block paste in `input` or `textarea` elements
+- MUST add an `aria-label` to icon-only buttons
+
+## Animation
+
+- NEVER add animation unless it is explicitly requested
+- MUST animate only compositor props (`transform`, `opacity`)
+- NEVER animate layout properties (`width`, `height`, `top`, `left`, `margin`, `padding`)
+- SHOULD use `ease-out` on entrance animations
+- NEVER exceed `200ms` for interaction feedback
+- SHOULD respect `prefers-reduced-motion`
+
+## Performance
+
+- NEVER animate large `blur()` or `backdrop-filter` surfaces
+- NEVER apply `will-change` outside an active animation
+- NEVER use `useEffect` for anything that can be expressed as render logic

package/skills/stripe/metadata.json

@@ -0,0 +1,16 @@
+{
+  "version": "1.0.0",
+  "organization": "Stripe",
+  "source": "https://stripe.com",
+  "extracted": "2026-01-25",
+  "categories": [
+    "ui-design",
+    "light-mode"
+  ],
+  "tokens": {
+    "colors": 10,
+    "typography": 62,
+    "spacing": 0,
+    "borders": 7
+  }
+}

package/skills/swift-actor-persistence/SKILL.md

@@ -0,0 +1,143 @@
+---
+name: swift-actor-persistence
+description: Thread-safe data persistence in Swift using actors — in-memory cache with file-backed storage, eliminating data races by design.
+origin: ECC
+---
+
+# Swift Actors for Thread-Safe Persistence
+
+Patterns for building thread-safe data persistence layers using Swift actors. Combines in-memory caching with file-backed storage, leveraging the actor model to eliminate data races at compile time.
+
+## When to Activate
+
+- Building a data persistence layer in Swift 5.5+
+- Need thread-safe access to shared mutable state
+- Want to eliminate manual synchronization (locks, DispatchQueues)
+- Building offline-first apps with local storage
+
+## Core Pattern
+
+### Actor-Based Repository
+
+The actor model guarantees serialized access — no data races, enforced by the compiler.
+
+```swift
+public actor LocalRepository<T: Codable & Identifiable> where T.ID == String {
+    private var cache: [String: T] = [:]
+    private let fileURL: URL
+
+    public init(directory: URL = .documentsDirectory, filename: String = "data.json") {
+        self.fileURL = directory.appendingPathComponent(filename)
+        // Synchronous load during init (actor isolation not yet active)
+        self.cache = Self.loadSynchronously(from: fileURL)
+    }
+
+    // MARK: - Public API
+
+    public func save(_ item: T) throws {
+        cache[item.id] = item
+        try persistToFile()
+    }
+
+    public func delete(_ id: String) throws {
+        cache[id] = nil
+        try persistToFile()
+    }
+
+    public func find(by id: String) -> T? {
+        cache[id]
+    }
+
+    public func loadAll() -> [T] {
+        Array(cache.values)
+    }
+
+    // MARK: - Private
+
+    private func persistToFile() throws {
+        let data = try JSONEncoder().encode(Array(cache.values))
+        try data.write(to: fileURL, options: .atomic)
+    }
+
+    private static func loadSynchronously(from url: URL) -> [String: T] {
+        guard let data = try? Data(contentsOf: url),
+              let items = try? JSONDecoder().decode([T].self, from: data) else {
+            return [:]
+        }
+        return Dictionary(uniqueKeysWithValues: items.map { ($0.id, $0) })
+    }
+}
+```
+
+### Usage
+
+All calls are automatically async due to actor isolation:
+
+```swift
+let repository = LocalRepository<Question>()
+
+// Read — fast O(1) lookup from in-memory cache
+let question = await repository.find(by: "q-001")
+let allQuestions = await repository.loadAll()
+
+// Write — updates cache and persists to file atomically
+try await repository.save(newQuestion)
+try await repository.delete("q-001")
+```
+
+### Combining with @Observable ViewModel
+
+```swift
+@Observable
+final class QuestionListViewModel {
+    private(set) var questions: [Question] = []
+    private let repository: LocalRepository<Question>
+
+    init(repository: LocalRepository<Question> = LocalRepository()) {
+        self.repository = repository
+    }
+
+    func load() async {
+        questions = await repository.loadAll()
+    }
+
+    func add(_ question: Question) async throws {
+        try await repository.save(question)
+        questions = await repository.loadAll()
+    }
+}
+```
+
+## Key Design Decisions
+
+| Decision | Rationale |
+|----------|-----------|
+| Actor (not class + lock) | Compiler-enforced thread safety, no manual synchronization |
+| In-memory cache + file persistence | Fast reads from cache, durable writes to disk |
+| Synchronous init loading | Avoids async initialization complexity |
+| Dictionary keyed by ID | O(1) lookups by identifier |
+| Generic over `Codable & Identifiable` | Reusable across any model type |
+| Atomic file writes (`.atomic`) | Prevents partial writes on crash |
+
+## Best Practices
+
+- **Use `Sendable` types** for all data crossing actor boundaries
+- **Keep the actor's public API minimal** — only expose domain operations, not persistence details
+- **Use `.atomic` writes** to prevent data corruption if the app crashes mid-write
+- **Load synchronously in `init`** — async initializers add complexity with minimal benefit for local files
+- **Combine with `@Observable`** ViewModels for reactive UI updates
+
+## Anti-Patterns to Avoid
+
+- Using `DispatchQueue` or `NSLock` instead of actors for new Swift concurrency code
+- Exposing the internal cache dictionary to external callers
+- Making the file URL configurable without validation
+- Forgetting that all actor method calls are `await` — callers must handle async context
+- Using `nonisolated` to bypass actor isolation (defeats the purpose)
+
+## When to Use
+
+- Local data storage in iOS/macOS apps (user data, settings, cached content)
+- Offline-first architectures that sync to a server later
+- Any shared mutable state that multiple parts of the app access concurrently
+- Replacing legacy `DispatchQueue`-based thread safety with modern Swift concurrency

package/skills/swift-concurrency-6-2/SKILL.md

@@ -0,0 +1,216 @@
+---
+name: swift-concurrency-6-2
+description: Swift 6.2 Approachable Concurrency — single-threaded by default, @concurrent for explicit background offloading, isolated conformances for main actor types.
+---
+
+# Swift 6.2 Approachable Concurrency
+
+Patterns for adopting Swift 6.2's concurrency model where code runs single-threaded by default and concurrency is introduced explicitly. Eliminates common data-race errors without sacrificing performance.
+
+## When to Activate
+
+- Migrating Swift 5.x or 6.0/6.1 projects to Swift 6.2
+- Resolving data-race safety compiler errors
+- Designing MainActor-based app architecture
+- Offloading CPU-intensive work to background threads
+- Implementing protocol conformances on MainActor-isolated types
+- Enabling Approachable Concurrency build settings in Xcode 26
+
+## Core Problem: Implicit Background Offloading
+
+In Swift 6.1 and earlier, async functions could be implicitly offloaded to background threads, causing data-race errors even in seemingly safe code:
+
+```swift
+// Swift 6.1: ERROR
+@MainActor
+final class StickerModel {
+    let photoProcessor = PhotoProcessor()
+
+    func extractSticker(_ item: PhotosPickerItem) async throws -> Sticker? {
+        guard let data = try await item.loadTransferable(type: Data.self) else { return nil }
+
+        // Error: Sending 'self.photoProcessor' risks causing data races
+        return await photoProcessor.extractSticker(data: data, with: item.itemIdentifier)
+    }
+}
+```
+
+Swift 6.2 fixes this: async functions stay on the calling actor by default.
+
+```swift
+// Swift 6.2: OK — async stays on MainActor, no data race
+@MainActor
+final class StickerModel {
+    let photoProcessor = PhotoProcessor()
+
+    func extractSticker(_ item: PhotosPickerItem) async throws -> Sticker? {
+        guard let data = try await item.loadTransferable(type: Data.self) else { return nil }
+        return await photoProcessor.extractSticker(data: data, with: item.itemIdentifier)
+    }
+}
+```
+
+## Core Pattern — Isolated Conformances
+
+MainActor types can now conform to non-isolated protocols safely:
+
+```swift
+protocol Exportable {
+    func export()
+}
+
+// Swift 6.1: ERROR — crosses into main actor-isolated code
+// Swift 6.2: OK with isolated conformance
+extension StickerModel: @MainActor Exportable {
+    func export() {
+        photoProcessor.exportAsPNG()
+    }
+}
+```
+
+The compiler ensures the conformance is only used on the main actor:
+
+```swift
+// OK — ImageExporter is also @MainActor
+@MainActor
+struct ImageExporter {
+    var items: [any Exportable]
+
+    mutating func add(_ item: StickerModel) {
+        items.append(item)  // Safe: same actor isolation
+    }
+}
+
+// ERROR — nonisolated context can't use MainActor conformance
+nonisolated struct ImageExporter {
+    var items: [any Exportable]
+
+    mutating func add(_ item: StickerModel) {
+        items.append(item)  // Error: Main actor-isolated conformance cannot be used here
+    }
+}
+```
+
+## Core Pattern — Global and Static Variables
+
+Protect global/static state with MainActor:
+
+```swift
+// Swift 6.1: ERROR — non-Sendable type may have shared mutable state
+final class StickerLibrary {
+    static let shared: StickerLibrary = .init()  // Error
+}
+
+// Fix: Annotate with @MainActor
+@MainActor
+final class StickerLibrary {
+    static let shared: StickerLibrary = .init()  // OK
+}
+```
+
+### MainActor Default Inference Mode
+
+Swift 6.2 introduces a mode where MainActor is inferred by default — no manual annotations needed:
+
+```swift
+// With MainActor default inference enabled:
+final class StickerLibrary {
+    static let shared: StickerLibrary = .init()  // Implicitly @MainActor
+}
+
+final class StickerModel {
+    let photoProcessor: PhotoProcessor
+    var selection: [PhotosPickerItem]  // Implicitly @MainActor
+}
+
+extension StickerModel: Exportable {  // Implicitly @MainActor conformance
+    func export() {
+        photoProcessor.exportAsPNG()
+    }
+}
+```
+
+This mode is opt-in and recommended for apps, scripts, and other executable targets.
+
+## Core Pattern — @concurrent for Background Work
+
+When you need actual parallelism, explicitly offload with `@concurrent`:
+
+> **Important:** This example requires Approachable Concurrency build settings — SE-0466 (MainActor default isolation) and SE-0461 (NonisolatedNonsendingByDefault). With these enabled, `extractSticker` stays on the caller's actor, making mutable state access safe. **Without these settings, this code has a data race** — the compiler will flag it.
+
+```swift
+nonisolated final class PhotoProcessor {
+    private var cachedStickers: [String: Sticker] = [:]
+
+    func extractSticker(data: Data, with id: String) async -> Sticker {
+        if let sticker = cachedStickers[id] {
+            return sticker
+        }
+
+        let sticker = await Self.extractSubject(from: data)
+        cachedStickers[id] = sticker
+        return sticker
+    }
+
+    // Offload expensive work to concurrent thread pool
+    @concurrent
+    static func extractSubject(from data: Data) async -> Sticker { /* ... */ }
+}
+
+// Callers must await
+let processor = PhotoProcessor()
+processedPhotos[item.id] = await processor.extractSticker(data: data, with: item.id)
+```
+
+To use `@concurrent`:
+1. Mark the containing type as `nonisolated`
+2. Add `@concurrent` to the function
+3. Add `async` if not already asynchronous
+4. Add `await` at call sites
+
+## Key Design Decisions
+
+| Decision | Rationale |
+|----------|-----------|
+| Single-threaded by default | Most natural code is data-race free; concurrency is opt-in |
+| Async stays on calling actor | Eliminates implicit offloading that caused data-race errors |
+| Isolated conformances | MainActor types can conform to protocols without unsafe workarounds |
+| `@concurrent` explicit opt-in | Background execution is a deliberate performance choice, not accidental |
+| MainActor default inference | Reduces boilerplate `@MainActor` annotations for app targets |
+| Opt-in adoption | Non-breaking migration path — enable features incrementally |
+
+## Migration Steps
+
+1. **Enable in Xcode**: Swift Compiler > Concurrency section in Build Settings
+2. **Enable in SPM**: Use `SwiftSettings` API in package manifest
+3. **Use migration tooling**: Automatic code changes via swift.org/migration
+4. **Start with MainActor defaults**: Enable inference mode for app targets
+5. **Add `@concurrent` where needed**: Profile first, then offload hot paths
+6. **Test thoroughly**: Data-race issues become compile-time errors
+
+## Best Practices
+
+- **Start on MainActor** — write single-threaded code first, optimize later
+- **Use `@concurrent` only for CPU-intensive work** — image processing, compression, complex computation
+- **Enable MainActor inference mode** for app targets that are mostly single-threaded
+- **Profile before offloading** — use Instruments to find actual bottlenecks
+- **Protect globals with MainActor** — global/static mutable state needs actor isolation
+- **Use isolated conformances** instead of `nonisolated` workarounds or `@Sendable` wrappers
+- **Migrate incrementally** — enable features one at a time in build settings
+
+## Anti-Patterns to Avoid
+
+- Applying `@concurrent` to every async function (most don't need background execution)
+- Using `nonisolated` to suppress compiler errors without understanding isolation
+- Keeping legacy `DispatchQueue` patterns when actors provide the same safety
+- Skipping `model.availability` checks in concurrency-related Foundation Models code
+- Fighting the compiler — if it reports a data race, the code has a real concurrency issue
+- Assuming all async code runs in the background (Swift 6.2 default: stays on calling actor)
+
+## When to Use
+
+- All new Swift 6.2+ projects (Approachable Concurrency is the recommended default)
+- Migrating existing apps from Swift 5.x or 6.0/6.1 concurrency
+- Resolving data-race safety compiler errors during Xcode 26 adoption
+- Building MainActor-centric app architectures (most UI apps)
+- Performance optimization — offloading specific heavy computations to background