imhcode 1.0.0

package/skills/theme-factory/themes/modern-minimalist.md

@@ -0,0 +1,19 @@
+# Modern Minimalist
+
+A clean and contemporary theme with a sophisticated grayscale palette for maximum versatility.
+
+## Color Palette
+
+- **Charcoal**: `#36454f` - Primary dark color
+- **Slate Gray**: `#708090` - Medium gray for accents
+- **Light Gray**: `#d3d3d3` - Backgrounds and dividers
+- **White**: `#ffffff` - Text and clean backgrounds
+
+## Typography
+
+- **Headers**: DejaVu Sans Bold
+- **Body Text**: DejaVu Sans
+
+## Best Used For
+
+Tech presentations, architecture portfolios, design showcases, modern business proposals, data visualization.

package/skills/theme-factory/themes/ocean-depths.md

@@ -0,0 +1,19 @@
+# Ocean Depths
+
+A professional and calming maritime theme that evokes the serenity of deep ocean waters.
+
+## Color Palette
+
+- **Deep Navy**: `#1a2332` - Primary background color
+- **Teal**: `#2d8b8b` - Accent color for highlights and emphasis
+- **Seafoam**: `#a8dadc` - Secondary accent for lighter elements
+- **Cream**: `#f1faee` - Text and light backgrounds
+
+## Typography
+
+- **Headers**: DejaVu Sans Bold
+- **Body Text**: DejaVu Sans
+
+## Best Used For
+
+Corporate presentations, financial reports, professional consulting decks, trust-building content.

package/skills/theme-factory/themes/sunset-boulevard.md

@@ -0,0 +1,19 @@
+# Sunset Boulevard
+
+A warm and vibrant theme inspired by golden hour sunsets, perfect for energetic and creative presentations.
+
+## Color Palette
+
+- **Burnt Orange**: `#e76f51` - Primary accent color
+- **Coral**: `#f4a261` - Secondary warm accent
+- **Warm Sand**: `#e9c46a` - Highlighting and backgrounds
+- **Deep Purple**: `#264653` - Dark contrast and text
+
+## Typography
+
+- **Headers**: DejaVu Serif Bold
+- **Body Text**: DejaVu Sans
+
+## Best Used For
+
+Creative pitches, marketing presentations, lifestyle brands, event promotions, inspirational content.

package/skills/theme-factory/themes/tech-innovation.md

@@ -0,0 +1,19 @@
+# Tech Innovation
+
+A bold and modern theme with high-contrast colors perfect for cutting-edge technology presentations.
+
+## Color Palette
+
+- **Electric Blue**: `#0066ff` - Vibrant primary accent
+- **Neon Cyan**: `#00ffff` - Bright highlight color
+- **Dark Gray**: `#1e1e1e` - Deep backgrounds
+- **White**: `#ffffff` - Clean text and contrast
+
+## Typography
+
+- **Headers**: DejaVu Sans Bold
+- **Body Text**: DejaVu Sans
+
+## Best Used For
+
+Tech startups, software launches, innovation showcases, AI/ML presentations, digital transformation content.

package/skills/threejs-webgl/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: threejs-webgl
+description: threejs webgl — loaded from design-skills plugin
+source: design-skills-plugin
+---
+# Threejs Webgl
+
+> **Plugin Skill**: This skill is provided by the `design-skills` plugin. When available, read the full skill from the plugin directory. When not available, use the agent's embedded knowledge of threejs webgl patterns.

package/skills/trailofbits-auditing/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: trailofbits-auditing
+description: "Smart contract auditing and secure cryptography implementation skill. Covers Solidity reentrancy, access control, cryptographic key management, and zero-knowledge heuristics."
+---
+
+# /trailofbits-auditing — Smart Contract & Cryptography Audits
+
+**Trailofbits-Auditing** implements highly rigorous static analysis, cryptographic verification, and smart contract auditing practices.
+
+---
+
+## 🔐 Audit Domains
+
+### 1. Smart Contract Auditing (Solidity/Rust)
+- **Reentrancy Guards**: Verify use of the Checks-Effects-Interactions pattern and `nonReentrant` modifiers.
+- **Access Control**: Audit ownership parameters (`Ownable`, `AccessControl`). Ensure no public setters lack guards.
+- **Gas Optimization**: Detect gas-sinks, unnecessary storage writes, and unoptimized loops.
+- **Math Overflow**: Enforce Solidity 0.8+ checked arithmetic or SafeMath libraries where applicable.
+
+### 2. Cryptographic Key Management & Verification
+- **Entropy & Randomness**: Prevent using chain variables (e.g., `block.timestamp`) for randomness; enforce Chainlink VRF.
+- **Encryption Standards**: Check that AES-GCM or ChaCha20-Poly1305 are used for symmetric encryption, and Argon2id for password hashing.
+- **Signatures**: Enforce ERC-20 EIP-712 typed signature verifications and prevent replay attacks.
+
+---
+
+## 🚫 Audit Red Flags
+- **Access Flaws**: Internal functions exposed as external/public.
+- **State Coupling**: State variables updated *after* transferring ether/tokens.
+- **Roll-Your-Own Crypto**: Always reject custom cryptographic implementations. Enforce OpenZeppelin and standard libraries.

package/skills/twitter-algorithm-optimizer/SKILL.md

@@ -0,0 +1,327 @@
+---
+name: twitter-algorithm-optimizer
+description: Analyze and optimize tweets for maximum reach using Twitter's open-source algorithm insights. Rewrite and edit user tweets to improve engagement and visibility based on how the recommendation system ranks content.
+license: AGPL-3.0 (referencing Twitter's algorithm source)
+---
+
+# Twitter Algorithm Optimizer
+
+## When to Use This Skill
+
+Use this skill when you need to:
+- **Optimize tweet drafts** for maximum reach and engagement
+- **Understand why** a tweet might not perform well algorithmically
+- **Rewrite tweets** to align with Twitter's ranking mechanisms
+- **Improve content strategy** based on the actual ranking algorithms
+- **Debug underperforming content** and increase visibility
+- **Maximize engagement signals** that Twitter's algorithms track
+
+## What This Skill Does
+
+1. **Analyzes tweets** against Twitter's core recommendation algorithms
+2. **Identifies optimization opportunities** based on engagement signals
+3. **Rewrites and edits tweets** to improve algorithmic ranking
+4. **Explains the "why"** behind recommendations using algorithm insights
+5. **Applies Real-graph, SimClusters, and TwHIN principles** to content strategy
+6. **Provides engagement-boosting tactics** grounded in Twitter's actual systems
+
+## How It Works: Twitter's Algorithm Architecture
+
+Twitter's recommendation system uses multiple interconnected models:
+
+### Core Ranking Models
+
+**Real-graph**: Predicts interaction likelihood between users
+- Determines if your followers will engage with your content
+- Affects how widely Twitter shows your tweet to others
+- Key signal: Will followers like, reply, or retweet this?
+
+**SimClusters**: Community detection with sparse embeddings
+- Identifies communities of users with similar interests
+- Determines if your tweet resonates within specific communities
+- Key strategy: Make content that appeals to tight communities who will engage
+
+**TwHIN**: Knowledge graph embeddings for users and posts
+- Maps relationships between users and content topics
+- Helps Twitter understand if your tweet fits your follower interests
+- Key strategy: Stay in your niche or clearly signal topic shifts
+
+**Tweepcred**: User reputation/authority scoring
+- Higher-credibility users get more distribution
+- Your past engagement history affects current tweet reach
+- Key strategy: Build reputation through consistent engagement
+
+### Engagement Signals Tracked
+
+Twitter's **Unified User Actions** service tracks both explicit and implicit signals:
+
+**Explicit Signals** (high weight):
+- Likes (direct positive signal)
+- Replies (indicates valuable content worth discussing)
+- Retweets (strongest signal - users want to share it)
+- Quote tweets (engaged discussion)
+
+**Implicit Signals** (also weighted):
+- Profile visits (curiosity about the author)
+- Clicks/link clicks (content deemed useful enough to explore)
+- Time spent (users reading/considering your tweet)
+- Saves/bookmarks (plan to return later)
+
+**Negative Signals**:
+- Block/report (Twitter penalizes this heavily)
+- Mute/unfollow (person doesn't want your content)
+- Skip/scroll past quickly (low engagement)
+
+### The Feed Generation Process
+
+Your tweet reaches users through this pipeline:
+
+1. **Candidate Retrieval** - Multiple sources find candidate tweets:
+   - Search Index (relevant keyword matches)
+   - UTEG (timeline engagement graph - following relationships)
+   - Tweet-mixer (trending/viral content)
+
+2. **Ranking** - ML models rank candidates by predicted engagement:
+   - Will THIS user engage with THIS tweet?
+   - How quickly will engagement happen?
+   - Will it spread to non-followers?
+
+3. **Filtering** - Remove blocked content, apply preferences
+
+4. **Delivery** - Show ranked feed to user
+
+## Optimization Strategies Based on Algorithm Insights
+
+### 1. Maximize Real-graph (Follower Engagement)
+
+**Strategy**: Make content your followers WILL engage with
+
+- **Know your audience**: Reference topics they care about
+- **Ask questions**: Direct questions get more replies than statements
+- **Create controversy (safely)**: Debate attracts engagement (but avoid blocks/reports)
+- **Tag related creators**: Increases visibility through networks
+- **Post when followers are active**: Better early engagement means better ranking
+
+**Example Optimization**:
+- ❌ "I think climate policy is important"
+- ✅ "Hot take: Current climate policy ignores nuclear energy. Thoughts?" (triggers replies)
+
+### 2. Leverage SimClusters (Community Resonance)
+
+**Strategy**: Find and serve tight communities deeply interested in your topic
+
+- **Pick ONE clear topic**: Don't confuse the algorithm with mixed messages
+- **Use community language**: Reference shared memes, inside jokes, terminology
+- **Provide value to the niche**: Be genuinely useful to that specific community
+- **Encourage community-to-community sharing**: Quotes that spark discussion
+- **Build in your lane**: Consistency helps algorithm understand your topic
+
+**Example Optimization**:
+- ❌ "I use many programming languages"
+- ✅ "Rust's ownership system is the most underrated feature. Here's why..." (targets specific dev community)
+
+### 3. Improve TwHIN Mapping (Content-User Fit)
+
+**Strategy**: Make your content clearly relevant to your established identity
+
+- **Signal your expertise**: Lead with domain knowledge
+- **Consistency matters**: Stay in your lanes (or clearly announce a new direction)
+- **Use specific terminology**: Helps algorithm categorize you correctly
+- **Reference your past wins**: "Following up on my tweet about X..."
+- **Build topical authority**: Multiple tweets on same topic strengthen the connection
+
+**Example Optimization**:
+- ❌ "I like lots of things" (vague, confuses algorithm)
+- ✅ "My 3rd consecutive framework review as a full-stack engineer" (establishes authority)
+
+### 4. Boost Tweepcred (Authority/Credibility)
+
+**Strategy**: Build reputation through engagement consistency
+
+- **Reply to top creators**: Interaction with high-credibility accounts boosts visibility
+- **Quote interesting tweets**: Adds value and signals engagement
+- **Avoid engagement bait**: Doesn't build real credibility
+- **Be consistent**: Regular quality posting beats sporadic viral attempts
+- **Engage deeply**: Quality replies and discussions matter more than volume
+
+**Example Optimization**:
+- ❌ "RETWEET IF..." (engagement bait, damages credibility over time)
+- ✅ "Thoughtful critique of the approach in [linked tweet]" (builds authority)
+
+### 5. Maximize Engagement Signals
+
+**Explicit Signal Triggers**:
+
+**For Likes**:
+- Novel insights or memorable phrasing
+- Validation of audience beliefs
+- Useful/actionable information
+- Strong opinions with supporting evidence
+
+**For Replies**:
+- Ask a direct question
+- Create a debate
+- Request opinions
+- Share incomplete thoughts (invites completion)
+
+**For Retweets**:
+- Useful information people want to share
+- Representational value (tweet speaks for them)
+- Entertainment that entertains their followers
+- Information advantage (breaking news first)
+
+**For Bookmarks/Saves**:
+- Tutorials or how-tos
+- Data/statistics they'll reference later
+- Inspiration or motivation
+- Jokes/entertainment they'll want to see again
+
+**Example Optimization**:
+- ❌ "Check out this tool" (passive)
+- ✅ "This tool saved me 5 hours this week. Here's how to set it up..." (actionable, retweet-worthy)
+
+### 6. Prevent Negative Signals
+
+**Avoid**:
+- Inflammatory content likely to be reported
+- Targeted harassment (gets algorithmic penalty)
+- Misleading/false claims (damages credibility)
+- Off-brand pivots (confuses the algorithm)
+- Reply-guy syndrome (too many low-value replies)
+
+## How to Optimize Your Tweets
+
+### Step 1: Identify the Core Message
+- What's the single most important thing this tweet communicates?
+- Who should care about this?
+- What action/engagement do you want?
+
+### Step 2: Map to Algorithm Strategy
+- Which Real-graph follower segment will engage? (Followers who care about X)
+- Which SimCluster community? (Niche interested in Y)
+- How does this fit your TwHIN identity? (Your established expertise)
+- Does this boost or hurt Tweepcred?
+
+### Step 3: Optimize for Signals
+- Does it trigger replies? (Ask a question, create debate)
+- Is it retweet-worthy? (Usefulness, entertainment, representational value)
+- Will followers like it? (Novel, validating, actionable)
+- Could it go viral? (Community resonance + network effects)
+
+### Step 4: Check Against Negatives
+- Any blocks/reports risk?
+- Any confusion about your identity?
+- Any engagement bait that damages credibility?
+- Any inflammatory language that hurts Tweepcred?
+
+## Example Optimizations
+
+### Example 1: Developer Tweet
+
+**Original**:
+> "I fixed a bug today"
+
+**Algorithm Analysis**:
+- No clear audience - too generic
+- No engagement signals - statements don't trigger replies
+- No Real-graph trigger - followers won't engage strongly
+- No SimCluster resonance - could apply to any developer
+
+**Optimized**:
+> "Spent 2 hours debugging, turned out I was missing one semicolon. The best part? The linter didn't catch it.
+>
+> What's your most embarrassing bug? Drop it in replies 👇"
+
+**Why It Works**:
+- SimCluster trigger: Specific developer community
+- Real-graph trigger: Direct question invites replies
+- Tweepcred: Relatable vulnerability builds connection
+- Engagement: Likely replies (others share embarrassing bugs)
+
+### Example 2: Product Launch Tweet
+
+**Original**:
+> "We launched a new feature today. Check it out."
+
+**Algorithm Analysis**:
+- Passive voice - doesn't indicate impact
+- No specific benefit - followers don't know why to care
+- No community resonance - generic
+- Engagement bait risk if it feels like self-promotion
+
+**Optimized**:
+> "Spent 6 months on the one feature our users asked for most: export to PDF.
+>
+> 10x improvement in report generation time. Already live.
+>
+> What export format do you want next?"
+
+**Why It Works**:
+- Real-graph: Followers in your product space will engage
+- Specificity: "PDF export" + "10x improvement" triggers bookmarks (useful info)
+- Question: Ends with engagement trigger
+- Authority: You spent 6 months (shows credibility)
+- SimCluster: Product management/SaaS community resonates
+
+### Example 3: Opinion Tweet
+
+**Original**:
+> "I think remote work is better than office work"
+
+**Algorithm Analysis**:
+- Vague opinion - doesn't invite engagement
+- Could be debated either way - no clear position
+- No Real-graph hooks - followers unclear if they should care
+- Generic topic - dilutes your personal brand
+
+**Optimized**:
+> "Hot take: remote work works great for async tasks but kills creative collaboration.
+>
+> We're now hybrid: deep focus days remote, collab days in office.
+>
+> What's your team's balance? Genuinely curious what works."
+
+**Why It Works**:
+- Clear position: Not absolutes, nuanced stance
+- Debate trigger: "Hot take" signals discussion opportunity
+- Question: Direct engagement request
+- Real-graph: Followers in your industry will have opinions
+- SimCluster: CTOs, team leads, engineering managers will relate
+- Tweepcred: Nuanced thinking builds authority
+
+## Best Practices for Algorithm Optimization
+
+1. **Quality Over Virality**: Consistent engagement from your community beats occasional viral moments
+2. **Community First**: Deep resonance with 100 engaged followers beats shallow reach to 10,000
+3. **Authenticity Matters**: The algorithm rewards genuine engagement, not manipulation
+4. **Timing Helps**: Engage early when tweet is fresh (first hour critical)
+5. **Build Threads**: Threaded tweets often get more engagement than single tweets
+6. **Follow Up**: Reply to replies quickly - Twitter's algorithm favors active conversation
+7. **Avoid Spam**: Engagement pods and bots hurt long-term credibility
+8. **Track Your Performance**: Notice what YOUR audience engages with and iterate
+
+## Common Pitfalls to Avoid
+
+- **Generic statements**: Doesn't trigger algorithm (too vague)
+- **Pure engagement bait**: "Like if you agree" - hurts credibility long-term
+- **Unclear audience**: Who should care? If unclear, algorithm won't push it far
+- **Off-brand pivots**: Confuses algorithm about your identity
+- **Over-frequency**: Spamming hurts engagement rate metrics
+- **Toxicity**: Blocks/reports heavily penalize future reach
+- **No calls to action**: Passive tweets underperform
+
+## When to Ask for Algorithm Optimization
+
+Use this skill when:
+- You've drafted a tweet and want to maximize reach
+- A tweet underperformed and you want to understand why
+- You're launching important content and want algorithm advantage
+- You're building audience in a specific niche
+- You want to become known for something specific
+- You're debugging inconsistent engagement rates
+
+Use Claude without this skill for:
+- General writing and grammar fixes
+- Tone adjustments not related to algorithm
+- Off-Twitter content (LinkedIn, Medium, blogs, etc.)
+- Personal conversations and casual tweets

package/skills/typeui-cli/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: typeui-cli
+description: Guide for agentic tools to use the typeui.sh CLI for generating, updating, listing, and pulling design system skill files.
+license: MIT
+metadata:
+  author: typeui.sh
+---
+
+# typeui.sh CLI Operator Skill
+
+## Mission
+
+Use `typeui.sh` to generate, update, list, and pull design-system skill files for agentic tooling in a project.
+
+## When To Use This Skill
+
+- User asks to create or refresh design-system instructions for agents.
+- User wants to pull an existing style by slug.
+- User wants to browse available styles and select one interactively.
+- User asks for preview-only runs before writing files.
+
+## Preconditions
+
+- Run commands from the target project root.
+- Node.js 18+ is available.
+- If running from this repository source, build first:
+  - `npm install`
+  - `npm run build`
+
+## Command Reference
+
+- `npx typeui.sh generate`
+  - Run interactive prompts and create new managed skill content.
+- `npx typeui.sh update`
+  - Update existing managed sections in generated files.
+- `npx typeui.sh pull <slug>`
+  - Pull a specific registry skill and write it to selected provider paths.
+- `npx typeui.sh list`
+  - List available registry slugs, show preview links, and pull one selection.
+
+## Local Dev Invocation (This Repo)
+
+- `node dist/cli.js --help`
+- `node dist/cli.js generate`
+- `node dist/cli.js update`
+- `node dist/cli.js list`
+- `node dist/cli.js pull <slug>`
+
+## Shared Flags
+
+- `-p, --providers <providers>`
+  - Comma-separated providers (example: `cursor,codex`).
+- `--dry-run`
+  - Preview file changes without writing.
+
+## Provider Behavior
+
+- Universal target is always included: `.agents/skills/design-system/SKILL.md`.
+- Selected providers add extra output targets (for example `.cursor/...`, `.codex/...`).
+
+## Registry Behavior
+
+- Source of truth for list/pull data is:
+  - `https://github.com/bergside/awesome-design-skills`
+- Registry index used by CLI:
+  - `https://raw.githubusercontent.com/bergside/awesome-design-skills/main/skills/index.json`
+- `pull <slug>` flow:
+  1. Validate slug format.
+  2. Resolve `skillPath` from index.
+  3. Fetch markdown from the raw GitHub path.
+- `list` flow:
+  - Reads the same index and shows preview links from:
+  - `https://www.typeui.sh/design-systems/<slug>`
+
+## Recommended Agent Workflow
+
+1. If user knows the style: run `pull <slug> --dry-run` first.
+2. If user does not know the style: run `list` and select one.
+3. Re-run without `--dry-run` when preview looks correct.
+4. Report generated/updated file paths and whether each changed.
+
+## Troubleshooting
+
+- `Registry pull failed: not_found`
+  - Slug is not in registry index or markdown path is missing.
+  - Run `list` and pick a valid slug.
+- `Slug must contain only lowercase letters, numbers, dashes, or underscores`
+  - Normalize slug format before retrying.
+- `No existing managed design system found` during `update`
+  - Run `generate` first to create managed blocks.

package/skills/typeui-main/DESIGN.md

@@ -0,0 +1,114 @@
+# Design System Skill Blueprint
+
+Canonical source-of-truth blueprint for authoring reusable `skill.md` files for design systems across repositories.
+
+## Purpose
+
+Use this blueprint to keep design-system skills consistent, implementation-ready, and SEO-friendly when published or indexed in docs.
+
+## Authoring Rules
+
+- Keep language concise and operational.
+- Prefer explicit rules over vague styling advice.
+- Use measurable constraints (tokens, states, thresholds).
+- Write in implementation-first order: foundations, components, accessibility, QA.
+- Use consistent terminology across the entire file.
+
+## Required `skill.md` Structure
+
+```md
+---
+name: design-system-[brand-or-scope]
+description: Creates implementation-ready design-system guidance with tokens, component behavior, and accessibility standards. Use when creating or updating UI rules, component specifications, or design-system documentation.
+---
+
+<!-- OPTIONAL MANAGED BLOCK MARKERS -->
+<!-- TYPEUI_SH_MANAGED_START -->
+
+# [Design System Name]
+
+## Mission
+One paragraph describing the system objective and target product experience.
+
+## Brand
+- Product/brand: [name]
+- Audience: [primary users]
+- Product surface: [web app, marketing site, dashboard, mobile web]
+
+## Style Foundations
+- Visual style: [keywords]
+- Typography scale: [token list]
+- Color palette: [semantic tokens + values]
+- Spacing scale: [token list]
+- Radius/shadow/motion tokens: [if applicable]
+
+## Accessibility
+- Target: WCAG 2.2 AA
+- Keyboard-first interactions required
+- Focus-visible rules required
+- Contrast constraints required
+
+## Writing Tone
+concise, confident, implementation-focused
+
+## Rules: Do
+- Use semantic tokens, not raw hex values in component guidance.
+- Define all required states: default, hover, focus-visible, active, disabled, loading, error.
+- Specify responsive behavior and edge-case handling.
+
+## Rules: Don't
+- Do not allow low-contrast text or hidden focus indicators.
+- Do not introduce one-off spacing or typography exceptions.
+- Do not use ambiguous labels or non-descriptive actions.
+
+## Guideline Authoring Workflow
+1. Restate design intent in one sentence.
+2. Define foundations and tokens.
+3. Define component anatomy, variants, and interactions.
+4. Add accessibility acceptance criteria.
+5. Add anti-patterns and migration notes.
+6. End with QA checklist.
+
+## Required Output Structure
+- Context and goals
+- Design tokens and foundations
+- Component-level rules (anatomy, variants, states, responsive behavior)
+- Accessibility requirements and testable acceptance criteria
+- Content and tone standards with examples
+- Anti-patterns and prohibited implementations
+- QA checklist
+
+## Component Rule Expectations
+- Include keyboard, pointer, and touch behavior.
+- Include spacing and typography token requirements.
+- Include long-content, overflow, and empty-state handling.
+
+## Quality Gates
+- Every non-negotiable rule uses "must".
+- Every recommendation uses "should".
+- Every accessibility rule is testable in implementation.
+- Prefer system consistency over local visual exceptions.
+
+<!-- TYPEUI_SH_MANAGED_END -->
+```
+
+## Repo-Specific Variables To Replace
+
+- `[brand-or-scope]` in `name`
+- System name and mission
+- Token values (typography, colors, spacing, motion)
+- Any framework-specific implementation notes
+
+## Optional Extensions
+
+- `reference.md` for deep component specs and rationale
+- `examples.md` for positive/negative UI examples
+- `scripts/` for linting or validating generated guidance
+
+## Acceptance Checklist
+
+- Frontmatter exists with valid `name` and `description`.
+- Guidance is under 500 lines for `skill.md` when possible.
+- Accessibility and interaction states are explicitly documented.
+- Rules are concrete, testable, and non-ambiguous.
+- Output can be reused in other repositories with only variable replacement.

package/skills/typeui-main/LICENSE.md

@@ -0,0 +1,9 @@
+# Released under MIT License
+
+Copyright (c) 2026 Bergside LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.