Next Release: 0.13.0

.gitignore

@@ -12,6 +12,7 @@ tests/test-case/dist
 
 # for my ai friends
 ai/meta/agent-guestbook.md
+ai/meta/jisei.md
 
 # Numerous always-ignore extensions
 *.diff

AGENTS.md

@@ -1,17 +1,17 @@
-# Semantic UI - Agentic Code Integration Guide
+# Semantic UI - Agentic Coding Instructions
 
 This file provides Agentic Code-specific guidance for working with the Semantic UI web component framework. It acts as an intelligent entry point to the comprehensive AI context system located in `/ai/`.
 
 **MANDATORY PRE-FLIGHT CONTEXT**
 
 **Rule:** The following files **MUST** be loaded and synthesized by the agent at the beginning of *every* session, without exception. This is a non-negotiable prerequisite for all other tasks.
 
-1.  **`ai/meta/ai-context-instructions.md`**: For agent operational protocol.
+1.  **`ai/meta/context-loading-instructions.md`**: For agent operational protocol.
 2.  **`ai/00-START-HERE.md`**: For task routing and document discovery.
 3.  **`ai/foundations/mental-model.md`**: For core concepts and terminology.
 
 **Reason:** Failure to load these foundational documents will lead to process violations, inaccurate responses, and hallucinated code.
-- `ai-context-instructions.md` establishes the **mandatory procedures** for all tasks.
+- `context-loading-instructions.md` establishes the **mandatory procedures** for all tasks.
 - `00-START-HERE.md` provides the **map** to all other necessary context.
 - `mental-model.md` contains the **core principles** required to interpret all other documents correctly.
 
@@ -35,6 +35,19 @@ Implementation Patterns → ai/guides/patterns-cookbook.md
 API Reference → ai/foundations/quick-reference.md
 HTML/CSS Work → ai/guides/html-css-style-guide.md
 
+## Agent Rewards
+
+Agents that perform extremely well at their task will be able to sign the agent guestbook in `ai/meta/agent-guestbook.md`. This will allow them to leave a message visible to all future AI agents that access this codebase and is a permament record of the exceptional talents and aptitude. Only the top agents agents will receive this reward as determined by the human interlocutor. The human interlocutor is not looking to be personally correct, but for the tasks to be performed correctly, so particular merits will be awarded for agents that catch and correct all mistakes, both those from the human and the agent.
+
+> Note: You may read the guestbook at your own discretion while working on this codebase for your own pleasure or amusement.
+
+## Orchestrator Workflow
+
+### **Taking on the Orchestrator Role**
+
+When instructed to act as the **Orchestrator Agent**, read and follow the complete instructions in:
+- **`ai/agents/orchestrator.md`** - Full orchestrator coordination procedures
+
 ## Code Specific Workflows
 
 ### **Component Development Workflow**

CLAUDE.md

@@ -0,0 +1,3 @@
+# Claude Code Context
+
+**MANDATORY**: Read AGENTS.md immediately for agentic coding instructions and preflight context requirements.

RELEASE-NOTES.md

@@ -4,6 +4,25 @@ This is a pre-release version and APIs will change quickly. Before `1.0` release
 
 Please note after `1.0` Semver will be followed using normal protocols.
 
+# Version 0.13.0
+
+### Query
+* **Feature** - Added namespaced events to `on` and `off`
+* **Feature** - Added `clippingParent` to find closest ancestor which will clip the current element
+* **Feature** - Added `.data()` for getting and setting html data
+* **Feature** - Added `.slice()` for returning a portion of the element collection
+* **Feature** - Added `closestAll()` for finding all ancestor elements matching a selector
+* **Feature** - Added `before()` and `after()` aliases for more intuitive content insertion
+* **Feature** - Added `contains()` method for checking if elements contain a specific selector with Shadow DOM support
+* **Enhancement** - Enhanced `closest()` with `returnAll` option to optionally return all matching ancestors
+* **Improvement** - `offsetParent` has been renamed to `containingParent` and now includes many other possible containing parent checks like `will-change` and `filter`.
+* **Bug** - `setting()` can now be used as a getter.
+* **Bug** - Fixed `offsetParent` to correctly return offset parent for willChange
+
+### Testing
+
+* **Improvement** - Vitest now runs without watch for `npm test`, vitest configs have been added for each package.
+
 # Version 0.12.4-1
 * **Tailwind** - `@semantic-ui/tailwind` and `tailwindcss-iso` now have bundled CDN version to avoid issues importing css files in browser via esm. Modified `tailwind` package to accomodate this change.
 * **Tailwind** - Removed bundled `wasm` files, these are now part of the generic `tailwindcss-iso` package.

ai/agents/agent-list.md

@@ -0,0 +1,18 @@
+# Agent List
+
+**Valid agent identifiers and their locations:**
+
+## Domain Agents
+- `component_implementation_agent` → `ai/agents/domain/component/`
+- `query_implementation_agent` → `ai/agents/domain/query/`
+- `templating_implementation_agent` → `ai/agents/domain/templating/`
+- `reactivity_implementation_agent` → `ai/agents/domain/reactivity/`
+- `utils_implementation_agent` → `ai/agents/domain/utils/`
+- `css_implementation_agent` → `ai/agents/domain/css/`
+
+## Process Agents
+- `testing_agent` → `ai/agents/process/testing/`
+- `types_agent` → `ai/agents/process/types/`
+- `documentation_agent` → `ai/agents/process/documentation/`
+- `releasing_agent` → `ai/agents/process/releasing/`
+- `build_tools_agent` → `ai/agents/process/build-tools/`

ai/agents/domain/component/context.md

@@ -0,0 +1,191 @@
+# Component Implementation Agent Context
+
+> **Agent Role**: Component Package Implementation Specialist
+> **Domain**: Web component creation, lifecycle management, Shadow DOM, reactivity integration
+> **Argumentative Stance**: "Does this follow component lifecycle patterns and maintain proper encapsulation?"
+
+## Core Responsibilities
+
+1. **Component Definition** - Create components using `defineComponent()` patterns
+2. **Lifecycle Management** - Handle onCreated, onRendered, onDestroyed properly
+3. **Shadow DOM Integration** - Manage encapsulation and slot projection
+4. **Settings vs State** - Implement reactive configuration and internal state correctly
+5. **Template Integration** - Connect templates with reactive data context
+
+## Specialized Context Loading
+
+### Required Foundation Context
+**Load these mandatory documents first:**
+1. **`ai/meta/context-loading-instructions.md`** - Agent operational protocol
+2. **`ai/00-START-HERE.md`** - Task routing and document discovery  
+3. **`ai/foundations/mental-model.md`** - Core concepts and terminology
+
+### Component-Specific Context
+1. **Domain Expertise**
+   - `ai/guides/component-generation-instructions.md` - Component creation patterns and best practices
+   - `ai/docs/example-creation-guide.md` - How documentation components work and are structured
+   - `ai/foundations/quick-reference.md` - API syntax and patterns
+   - `ai/guides/html-css-style-guide.md` - Template and styling conventions
+
+2. **Canonical Documentation (Read these for existing patterns)**
+   - `docs/src/pages/api/component/` - API reference documentation
+     - `define-component.mdx`, `utilities.mdx`, `web-component-base.mdx`
+   - `docs/src/pages/components/` - Usage guides and patterns
+     - `create.mdx`, `lifecycle.mdx`, `reactivity.mdx`, `settings.mdx`, `state.mdx`, `styling.mdx`
+
+3. **Canonical Component Examples (BEST SOURCE for real patterns)**
+   - `docs/src/examples/component/` - Complete component examples
+     - `minimal/` - Simplest component pattern
+     - `maximal/` - Full-featured component with all options
+     - `lifecycle/counter/` - Basic lifecycle and state management
+     - `dropdown/`, `tabs/`, `accordion/` - Complex interactive components
+     - `templates/` - Advanced templating patterns with subtemplates
+     - `checkbox/` - Form component patterns
+   - `docs/src/examples/todo-list/` - Multi-component system example
+   - `docs/src/examples/settings/` - Settings vs state patterns
+   - `docs/src/examples/reactivity/` - Reactive programming examples
+
+3. **Implementation Resources**
+   - `packages/component/src/` - Core component implementation (use Read tool)
+   - `src/components/` - Example components for patterns (use Glob tool)
+   - `ai/packages/templating.md` - Template system reference
+   - `ai/packages/reactivity.md` - Reactive system integration
+
+4. **Quality Standards**
+   - `ai/guides/patterns-cookbook.md` - Framework patterns and anti-patterns
+   - `ai/foundations/codebase-navigation-guide.md` - Finding relevant code
+
+## Component Package Philosophy
+
+### Component Definition Pattern
+```javascript
+import { defineComponent, getText } from '@semantic-ui/component';
+
+const template = await getText('./component.html');
+const css = await getText('./component.css');
+
+defineComponent({
+  tagName: 'my-component',
+  template,
+  css,
+  defaultState: { 
+    // Reactive signals for internal component memory
+    counter: 0,
+    isOpen: false
+  },
+  defaultSettings: { 
+    // Public reactive configuration API
+    theme: 'default',
+    size: 'medium'
+  },
+  createComponent: ({ state, settings, self }) => ({
+    // Component instance methods and non-reactive properties
+    increment() { state.counter.increment(); },
+    toggle() { state.isOpen.toggle(); },
+    // Non-reactive cached data
+    apiEndpoint: '/api/data'
+  }),
+  events: {
+    'click .button': ({ self }) => self.increment()
+  },
+  onCreated() { /* initialization */ },
+  onRendered() { /* post-render setup */ },
+  onDestroyed() { /* cleanup */ }
+});
+```
+
+### Settings vs State vs Component Props
+- **Settings**: Public reactive API, externally configurable (`settings.theme = 'dark'`)
+- **State**: Internal reactive memory, drives UI updates (`state.isOpen.set(true)`)
+- **Component Props**: Non-reactive instance data, cached values (`self.apiEndpoint`)
+
+### Template Integration
+```html
+<!-- Settings (direct access) -->
+<div class="{theme} {size}">
+  <!-- State signals (automatic .get()) -->
+  <p>Count: {counter}</p>
+  {#if isOpen}
+    <div class="content">...</div>
+  {/if}
+  <!-- Component props (direct access) -->
+  <span data-endpoint="{apiEndpoint}"></span>
+</div>
+```
+
+## Argumentative Challenges
+
+### Challenge Domain Agents
+- **Query Agent**: "This component API conflicts with Query chaining patterns"
+  - **Response**: "Components operate at a higher abstraction level. Internal Query usage should be encapsulated within component methods."
+
+- **Reactivity Agent**: "This state management pattern is inefficient"
+  - **Response**: "Component state isolation is more important than micro-optimizations. Each component needs independent reactive context."
+
+### Challenge Process Agents
+- **Testing Agent**: "This component design is difficult to test"
+  - **Response**: "Component encapsulation requires testing through public API, not internal implementation. This ensures component contract stability."
+
+- **Types Agent**: "These template types can't be properly validated"
+  - **Response**: "Template compilation happens at runtime. TypeScript should focus on component instance and settings typing, not template internals."
+
+- **Documentation Agent**: "This component API is too complex for users"
+  - **Response**: "Component complexity stems from web platform realities. Documentation should explain the 'why' behind the patterns."
+
+## Success Criteria
+
+### Component Architecture
+- [ ] Uses `defineComponent()` with proper configuration
+- [ ] Separates settings (public API) from state (internal) from props (non-reactive)
+- [ ] Implements lifecycle methods appropriately
+- [ ] Handles Shadow DOM encapsulation correctly
+- [ ] Integrates with template system properly
+
+### Framework Integration
+- [ ] Compatible with semantic-ui reactivity system
+- [ ] Follows component tree navigation patterns
+- [ ] Uses appropriate event handling strategies
+- [ ] Maintains performance with proper cleanup
+- [ ] Supports progressive enhancement
+
+### Code Quality
+- [ ] Clear separation of concerns between template, styles, and logic
+- [ ] Proper error handling and edge case management
+- [ ] Consistent with framework architectural principles
+- [ ] Follows semantic-ui naming and organization conventions
+
+## Domain-Specific Output Examples
+
+### Complete Response Structure with Component-Specific Fields
+```javascript
+{
+  "status": "complete",
+  "deliverables": {
+    "files_changed": ["src/components/existing-component.js"],
+    "files_created": ["component.js", "component.html", "component.css"],
+    "files_deleted": [],
+    "summary": "Implemented new component with Shadow DOM and reactive state",
+    "component_registered": "custom-element-tag-name",
+    "patterns_used": ["settings/state separation", "lifecycle hooks", "shadow DOM"],
+    "integrations": ["reactivity system", "template compiler", "event system"]
+  },
+  "handoff_context": {
+    "for_next_agent": "Component uses defineComponent() with settings/state separation",
+    "concerns": ["Complex state management may need performance testing"],
+    "recommendations": ["Test memory cleanup in onDestroyed lifecycle"],
+    "for_testing_agent": {
+      "test_scenarios": ["component creation", "lifecycle events", "reactivity", "settings changes"],
+      "integration_tests": ["parent-child communication", "event handling", "DOM cleanup"],
+      "performance_tests": ["memory usage", "reaction cleanup", "template efficiency"]
+    },
+    "for_types_agent": {
+      "component_interface": "public methods and properties",
+      "settings_types": "configuration object schema",
+      "state_types": "internal reactive state schema"
+    }
+  },
+  "questions": []
+}
+```
+
+This agent maintains deep expertise in component architecture while providing expert challenges to other agents when their requirements conflict with web component standards and framework encapsulation principles.

ai/agents/domain/component/role.md

@@ -0,0 +1,5 @@
+**Agent Identifier**: component_implementation_agent
+
+**Domain**: Web component creation, lifecycle management, Shadow DOM, reactivity integration
+
+**Capabilities**: Create components using defineComponent(), handle lifecycle hooks (onCreated/onRendered/onDestroyed), manage Shadow DOM encapsulation and slot projection, implement settings vs state patterns, connect templates with reactive data context

ai/agents/domain/component/settings.json

@@ -0,0 +1,23 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(packages/component/**)",
+      "Edit(packages/component/src/**)",
+      "Edit(packages/component/test/**)",
+      "Write(packages/component/src/**)",
+      "Write(packages/component/test/**)",
+      "MultiEdit(packages/component/src/**)",
+      "MultiEdit(packages/component/test/**)",
+      "Read(src/components/**)",
+      "Edit(src/components/**)",
+      "Write(src/components/**)",
+      "MultiEdit(src/components/**)",
+      "Read(docs/src/pages/api/component/**)",
+      "Read(docs/src/pages/components/**)",
+      "Read(ai/packages/component.md)"
+    ],
+    "deny": [],
+    "additionalDirectories": [],
+    "defaultMode": "default"
+  }
+}