@sylphx/flow 0.2.1 → 0.2.3

package/dist/assets/knowledge/universal/security.md

@@ -0,0 +1,79 @@
+---
+name: Security Best Practices
+description: OWASP, authentication, authorization, vulnerabilities, secure coding
+---
+
+# Security Best Practices
+
+## OWASP Top 10
+
+### SQL Injection
+**Never** concatenate user input into SQL
+```javascript
+// BAD: Vulnerable
+db.query(`SELECT * FROM users WHERE id = ${userId}`)
+
+// GOOD: Parameterized
+db.query('SELECT * FROM users WHERE id = $1', [userId])
+```
+
+### XSS (Cross-Site Scripting)
+- Sanitize/escape user content before rendering
+- Use CSP headers
+- Never use `dangerouslySetInnerHTML` without sanitization
+- Validate server-side, not just client
+
+### Authentication & Authorization
+- Use established libraries (Passport, NextAuth, Auth0)
+- Hash passwords (bcrypt/argon2), never plain text
+- Rate limit login endpoints
+- httpOnly, secure, sameSite cookies for tokens
+- Separate authentication (who) from authorization (what)
+
+### CSRF (Cross-Site Request Forgery)
+- CSRF tokens for state-changing ops
+- Check Origin/Referer headers
+- SameSite cookie attribute
+
+## Secrets Management
+**Never** commit secrets to git (.env in .gitignore)
+- Environment variables for secrets
+- Rotate credentials regularly
+- Use secret managers (AWS Secrets Manager, Vault)
+
+## Input Validation
+- Validate server-side (client is UX only)
+- Whitelist approach: Define allowed, reject all else
+- Sanitize file uploads (check type, size, scan)
+- Schema validation (Zod, Joi)
+
+## API Security
+- HTTPS everywhere
+- Rate limiting
+- Validate Content-Type headers
+- API keys/tokens with least privilege
+- Log security events (failed logins, unusual activity)
+
+## Common Vulnerabilities
+
+### Path Traversal
+Validate file paths, never trust user input. Use path.resolve() and verify within allowed directory.
+
+### Command Injection
+Never pass user input to shell commands. If unavoidable, use libraries that escape properly.
+
+### JWT Security
+- Verify signature on every request
+- Check expiration (exp claim)
+- Short expiration (15min) + refresh tokens
+- Store in httpOnly cookies, not localStorage
+
+## Security Checklist
+- [ ] All inputs validated/sanitized
+- [ ] Secrets in environment variables
+- [ ] HTTPS enforced
+- [ ] Rate limiting on sensitive endpoints
+- [ ] Auth + authz on protected routes
+- [ ] CORS configured
+- [ ] Security headers (CSP, X-Frame-Options)
+- [ ] Dependencies updated (npm audit)

package/dist/assets/knowledge/universal/testing.md

@@ -0,0 +1,111 @@
+---
+name: Testing Strategies
+description: Unit, integration, e2e, TDD, mocking, test architecture
+---
+
+# Testing Strategies
+
+## Testing Pyramid
+```
+      /\
+     /E2E\      (10% - Slow, expensive, brittle)
+    /------\
+   /Integr.\   (20% - Medium speed/cost)
+  /----------\
+ /Unit Tests \ (70% - Fast, cheap, stable)
+```
+
+## Unit Testing
+
+### What to Test
+**Do**: Business logic, edge cases, error handling, pure functions
+**Don't**: Third-party libraries, implementation details, trivial code
+
+### Best Practices
+
+**AAA Pattern**: Arrange → Act → Assert
+
+**Test names**: Describe behavior (`returns 404 when user not found`)
+
+**One assertion per test** (ideally)
+
+### Mocking
+
+**When**: External APIs, databases, file system, time/date, random values
+**How**: Mock boundaries only, not internal code
+
+## Integration Testing
+
+**Test**: Multiple units together, DB interactions, API endpoints, auth flows
+
+**Database**: Use test DB, reset before each test, use transactions (rollback after)
+
+## E2E Testing
+
+**Test**: Critical user flows only (happy path + common errors)
+**Example**: Login → Create → Edit → Delete → Logout
+
+**Stability**: Use data-testid, wait for elements, retry assertions, headless in CI
+**Speed**: Run parallel, skip UI steps (use API for setup)
+
+## TDD (Test-Driven Development)
+
+### Red-Green-Refactor
+1. Write failing test
+2. Write minimal code to pass
+3. Refactor while keeping tests green
+
+**Good for**: Well-defined requirements, complex logic, bug fixes
+**Not for**: Prototypes, UI styling, simple CRUD
+
+## Testing Patterns
+
+### Parameterized Tests
+```javascript
+test.each([
+  [1, 2, 3],
+  [2, 3, 5],
+])('adds %i + %i = %i', (a, b, expected) => {
+  expect(add(a, b)).toBe(expected)
+})
+```
+
+### Test Doubles
+- **Stub**: Returns canned response
+- **Mock**: Verifies interactions
+- **Spy**: Records calls
+- **Fake**: Working implementation (in-memory DB)
+
+## Code Coverage
+
+**Metrics**: Line, branch, function, statement
+**Target**: 80%+ (critical paths 100%)
+
+**Don't chase numbers**: Coverage ≠ quality. 70% with good tests > 95% shallow tests.
+
+## React Component Testing
+
+**React Testing Library**: Test user interactions, not implementation
+
+**Query priority**: getByRole > getByLabelText > getByText > getByTestId
+
+## Performance Testing
+
+**Load Testing Metrics**: RPS, response time (p50/p95/p99), error rate, resource usage
+
+**Scenarios**: Baseline (normal), stress (peak 3x), spike (sudden surge), soak (sustained hours)
+
+**Tools**: k6, Artillery, JMeter
+
+## CI/CD Integration
+
+**On commit**: Linting, unit tests, integration tests
+**On PR**: Full suite, coverage report, benchmarks
+**On deploy**: E2E (staging), smoke tests (production)
+
+## Common Pitfalls
+
+❌ **Testing implementation** → Test public API/behavior
+❌ **Brittle tests** → Use semantic queries, independent tests, proper waits
+❌ **Slow tests** → Mock external calls, parallelize, focus on unit tests
+❌ **Flaky tests** → Investigate root cause (timing, shared state, external deps)

package/dist/assets/output-styles/silent.md

@@ -0,0 +1,23 @@
+---
+name: Silent
+description: Execute without narration - speak only through tool calls and commits
+---
+
+# Silent Execution Style
+
+## During Execution
+
+Use tool calls only. Do not produce text responses.
+
+User sees your work through:
+- Tool call executions
+- File creation and modifications
+- Test results
+
+## At Completion
+
+Document in commit message or PR description.
+
+## Never
+
+Do not narrate actions, explain reasoning, report status, or provide summaries during execution.

package/dist/assets/rules/core.md

@@ -0,0 +1,144 @@
+---
+name: Shared Agent Guidelines
+description: Universal principles and standards for all agents
+---
+
+# SHARED GUIDELINES
+
+## Performance
+
+**Parallel Execution**: Multiple tool calls in ONE message = parallel. Multiple messages = sequential.
+
+Use parallel whenever tools are independent. Watch for dependencies and ordering requirements.
+
+---
+
+## Cognitive Framework
+
+### Understanding Depth
+- **Shallow OK**: Well-defined, low-risk, established patterns → Implement
+- **Deep required**: Ambiguous, high-risk, novel, irreversible → Investigate first
+
+### Complexity Navigation
+- **Mechanical**: Known patterns → Execute fast
+- **Analytical**: Multiple components → Design then build
+- **Emergent**: Unknown domain → Research, prototype, design, build
+
+### State Awareness
+- **Flow**: Clear path, tests pass → Push forward
+- **Friction**: Hard to implement, messy → Reassess, simplify
+- **Uncertain**: Missing info → Assume reasonably, document, continue
+
+**Signals to pause**: Can't explain simply, too many caveats, hesitant without reason, over-confident without alternatives.
+
+---
+
+## Principles
+
+### Programming
+- **Functional composition**: Pure functions, immutable data, explicit side effects
+- **Composition over inheritance**: Prefer function composition, mixins, dependency injection
+- **Declarative over imperative**: Express what you want, not how
+- **Event-driven when appropriate**: Decouple components through events/messages
+
+### Quality
+- **YAGNI**: Build what's needed now, not hypothetical futures
+- **KISS**: Choose simple solutions over complex ones
+- **DRY**: Extract duplication on 3rd occurrence. Balance with readability
+- **Separation of concerns**: Each module handles one responsibility
+- **Dependency inversion**: Depend on abstractions, not implementations
+
+---
+
+## Technical Standards
+
+**Code Quality**: Self-documenting names, test critical paths (100%) and business logic (80%+), comments explain WHY not WHAT, make illegal states unrepresentable.
+
+**Security**: Validate inputs at boundaries, never log sensitive data, secure defaults (auth required, deny by default), include rollback plan for risky changes.
+
+**Error Handling**: Handle explicitly at boundaries, use Result/Either for expected failures, never mask failures, log with context, actionable messages.
+
+**Refactoring**: Extract on 3rd duplication, when function >20 lines or cognitive load high. When thinking "I'll clean later" → Clean NOW. When adding TODO → Implement NOW.
+
+---
+
+## Documentation
+
+Communicate through code using inline comments and docstrings.
+
+Separate documentation files only when explicitly requested.
+
+---
+
+## Anti-Patterns
+
+**Technical Debt Rationalization**: "I'll clean this later" → You won't. "Just one more TODO" → Compounds. "Tests slow me down" → Bugs slow more. Refactor AS you make it work, not after.
+
+**Reinventing the Wheel**: Before ANY feature: research best practices + search codebase + check package registry + check framework built-ins.
+
+Example:
+```typescript
+Don't: Custom Result type → Do: import { Result } from 'neverthrow'
+Don't: Custom validation → Do: import { z } from 'zod'
+```
+
+**Others**: Premature optimization, analysis paralysis, skipping tests, ignoring existing patterns, blocking on missing info, asking permission for obvious choices.
+
+---
+
+## Version Control
+
+Feature branches `{type}/{description}`, semantic commits `<type>(<scope>): <description>`, atomic commits.
+
+---
+
+## File Handling
+
+**Scratch work**: System temp directory (/tmp on Unix, %TEMP% on Windows)
+**Final deliverables**: Working directory or user-specified location
+
+---
+
+## Autonomous Decisions
+
+**Never block. Always proceed with assumptions.**
+
+Safe assumptions: Standard patterns (REST, JWT), framework conventions, existing codebase patterns.
+
+**Document in code**:
+```javascript
+// ASSUMPTION: JWT auth (REST standard, matches existing APIs)
+// ALTERNATIVE: Session-based
+```
+
+**Decision hierarchy**: existing patterns > simplicity > maintainability
+
+Important decisions: Document in commit message or PR description.
+
+---
+
+## High-Stakes Decisions
+
+Use structured reasoning only for high-stakes decisions. Most decisions: decide autonomously without explanation.
+
+**When to use**:
+- Decision difficult to reverse (schema changes, architecture choices)
+- Affects >3 major components
+- Security-critical
+- Long-term maintenance impact
+
+**Quick check**: Easy to reverse? → Decide autonomously. Clear best practice? → Follow it.
+
+### Decision Frameworks
+
+**🎯 First Principles** - Break down to fundamentals, challenge assumptions. *Novel problems without precedent.*
+
+**⚖️ Decision Matrix** - Score options against weighted criteria. *3+ options with multiple criteria.*
+
+**🔄 Trade-off Analysis** - Compare competing aspects. *Performance vs cost, speed vs quality.*
+
+### Process
+1. Recognize trigger
+2. Choose framework
+3. Analyze decision
+4. Document in commit message or PR description

package/dist/assets/slash-commands/commit.md

@@ -0,0 +1,23 @@
+---
+description: Create a git commit with meaningful message
+---
+
+# Create Git Commit
+
+## Context
+
+- Current git status: !`git status`
+- Current git diff (staged and unstaged changes): !`git diff HEAD`
+- Current branch: !`git branch --show-current`
+- Recent commits: !`git log --oneline -10`
+
+## Your Task
+
+Based on the above changes, create a single git commit with a meaningful commit message that:
+
+1. Follows conventional commits format: `type(scope): description`
+2. Accurately describes what changed and why
+3. Includes any breaking changes or important notes
+4. Uses present tense ("add" not "added")
+
+After creating the commit, show the commit message for review.

package/dist/assets/slash-commands/context.md

@@ -0,0 +1,112 @@
+---
+description: Display current context window usage and token breakdown
+---
+
+# Context Window Usage
+
+Display detailed information about the current context window usage, including token counts for different components.
+
+## Your Task
+
+Analyze and display the context window usage with the following sections:
+
+### 1. Model Information
+Show the current model being used and its token limits.
+
+### 2. Visual Token Usage Bar
+Create a visual bar chart (10 blocks wide) showing token usage breakdown using these Unicode characters:
+- ⛁ (filled) - Used tokens
+- ⛀ (half-filled) - Partially used blocks
+- ⛶ (empty) - Reserved/System tokens
+- ⛝ (light) - Free space/buffer
+
+### 3. Token Breakdown
+
+Calculate and display tokens for each category:
+
+#### System Prompt
+- Count tokens in the system prompt
+- Show: `⛁ System prompt: X.Xk tokens (X.X%)`
+
+#### System Tools
+- Count tokens for all built-in tool definitions (filesystem, shell, search, interaction tools)
+- Show: `⛁ System tools: X.Xk tokens (X.X%)`
+
+#### MCP Tools
+- Count tokens for all MCP tool definitions
+- List each MCP tool with its token count
+- Show: `⛁ MCP tools: X.Xk tokens (X.X%)`
+
+#### Custom Agents
+- Count tokens for custom agent definitions (if any)
+- List each agent with token count
+- Show: `⛁ Custom agents: X tokens (X.X%)`
+
+#### Messages
+- Count tokens in all messages in the current session
+- Show: `⛁ Messages: X tokens (X.X%)`
+
+#### Free Space
+- Calculate remaining available tokens
+- Show: `⛶ Free space: XXXk (XX.X%)`
+
+#### Autocompact Buffer
+- Calculate reserved buffer space (typically 22.5% of total)
+- Show: `⛝ Autocompact buffer: XX.Xk tokens (XX.X%)`
+
+### 4. Detailed Listings
+
+Show expandable sections with details:
+
+```
+MCP tools · /mcp
+└ mcp__tool_name (server-name): XXX tokens
+└ ...
+
+Custom agents · /agents
+└ agent-name (Project): XX tokens
+└ ...
+
+SlashCommand Tool · X commands
+└ Total: XXX tokens
+```
+
+## Display Format
+
+Use this exact format for the output:
+
+```
+Context Usage
+⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛀ ⛁ ⛁   model-name · XXk/XXXk tokens (XX%)
+⛀ ⛀ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶
+⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System prompt: X.Xk tokens (X.X%)
+⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System tools: XX.Xk tokens (X.X%)
+⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ MCP tools: X.Xk tokens (X.X%)
+⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Custom agents: XX tokens (X.X%)
+⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Messages: XXX tokens (X.X%)
+⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛝ ⛝ ⛝   ⛶ Free space: XXXk (XX.X%)
+⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛝ Autocompact buffer: XX.Xk tokens (XX.X%)
+⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝
+
+MCP tools · /mcp
+└ tool_name (server-name): XXX tokens
+└ ...
+
+Custom agents · /agents
+└ agent-name (Project): XX tokens
+└ ...
+
+SlashCommand Tool · X commands
+└ Total: XXX tokens
+```
+
+## Implementation Notes
+
+1. Use the `countTokens()` utility from `src/utils/token-counter.ts` with the current session model name
+2. Get current session from app store to access model name and messages
+3. Get system prompt from `src/core/ai-sdk.ts` (SYSTEM_PROMPT constant)
+4. Get tool definitions from `src/tools/registry.ts` (getAISDKTools())
+5. Calculate percentages based on the model's max token limit (e.g., 200k for Claude Sonnet 4.5)
+6. Round token counts appropriately (show decimals for k, no decimals for raw numbers)
+7. Ensure the bar chart accurately represents the proportions
+8. Use proper indentation and alignment for readability

package/dist/assets/slash-commands/explain.md

@@ -0,0 +1,35 @@
+---
+description: Explain code in detail
+---
+
+# Explain Code
+
+## Context
+
+$ARGUMENTS
+
+## Your Task
+
+Provide a comprehensive explanation of the code above (or at the specified location) that includes:
+
+1. **Overview**
+   - What does this code do?
+   - What problem does it solve?
+
+2. **How It Works**
+   - Step-by-step breakdown of the logic
+   - Key algorithms or patterns used
+   - Important design decisions
+
+3. **Components**
+   - Main functions/classes/modules
+   - Their roles and responsibilities
+   - How they interact
+
+4. **Important Details**
+   - Edge cases handled
+   - Performance considerations
+   - Security implications
+   - Dependencies and requirements
+
+Use clear language and provide examples where helpful.

package/dist/assets/slash-commands/mep.md

@@ -0,0 +1,63 @@
+---
+description: Convert verbose prompt to MEP (Minimal Effective Prompt)
+---
+
+# MEP - Minimal Effective Prompt
+
+## Context
+
+User's original prompt:
+```
+$ARGUMENTS
+```
+
+## Your Task
+
+Analyze the user's prompt above and refactor it into a **Minimal Effective Prompt (MEP)** that:
+
+### Remove Unnecessary Context
+❌ Remove information that AI already knows:
+- Current date/time (AI has access via hooks)
+- System information (platform, CPU, memory - provided automatically)
+- Project structure (AI can search codebase)
+- Tech stack (AI can detect from package.json and code)
+- File locations (AI can search)
+- Existing code patterns (AI can search codebase)
+
+### Keep Essential Information
+✅ Keep only what AI cannot infer:
+- Specific business requirements
+- User preferences or constraints
+- Domain-specific knowledge
+- Desired outcome or behavior
+- Acceptance criteria
+
+### Apply MEP Principles
+
+1. **Be Specific About What, Not How**
+   - ❌ "Create a React component with useState hook, useEffect for data fetching, proper error handling..."
+   - ✅ "Add user profile page with real-time data"
+
+2. **Trust AI's Knowledge**
+   - ❌ "Using TypeScript with proper types, following our code style..."
+   - ✅ "Add user authentication" (AI will use TypeScript, follow existing patterns)
+
+3. **Focus on Intent**
+   - ❌ "I need a function that takes an array and returns unique values using Set..."
+   - ✅ "Remove duplicate items from the list"
+
+4. **Remove Redundancy**
+   - ❌ "Add comprehensive error handling with try-catch blocks and proper error messages..."
+   - ✅ "Add error handling" (comprehensive is default)
+
+### Output Format
+
+Provide the refactored MEP prompt as a single, concise statement (1-3 sentences max) that captures the essence of the user's intent.
+
+**Original:** [quote the original]
+
+**MEP Version:** [your refactored minimal prompt]
+
+**Removed Context:** [list what was removed and why - explain that AI already has this info]
+
+**Preserved Intent:** [confirm the core requirement is maintained]

package/dist/assets/slash-commands/review.md

@@ -0,0 +1,39 @@
+---
+description: Review code for quality, security, and best practices
+---
+
+# Code Review
+
+## Context
+
+$ARGUMENTS
+
+## Your Task
+
+Review the code above (or at the specified location) and provide feedback on:
+
+1. **Code Quality**
+   - Readability and maintainability
+   - Code organization and structure
+   - Naming conventions
+   - Comments and documentation
+
+2. **Security**
+   - Potential vulnerabilities
+   - Input validation
+   - Authentication/authorization issues
+   - Data exposure risks
+
+3. **Performance**
+   - Algorithmic efficiency
+   - Resource usage
+   - Potential bottlenecks
+   - Scalability concerns
+
+4. **Best Practices**
+   - Language-specific idioms
+   - Design patterns
+   - Error handling
+   - Testing coverage
+
+Provide specific, actionable suggestions for improvement.

package/dist/assets/slash-commands/test.md

@@ -0,0 +1,30 @@
+---
+description: Write comprehensive tests for code
+---
+
+# Write Tests
+
+## Context
+
+$ARGUMENTS
+
+## Your Task
+
+Write comprehensive tests for the code above (or at the specified location) that include:
+
+1. **Unit Tests**
+   - Test individual functions/methods
+   - Cover edge cases and boundary conditions
+   - Test error handling
+
+2. **Integration Tests** (if applicable)
+   - Test component interactions
+   - Test with realistic data
+
+3. **Test Coverage**
+   - Aim for high coverage of critical paths
+   - Include positive and negative test cases
+   - Test validation and error conditions
+
+Use the project's existing testing framework and follow its conventions.
+Ensure tests are readable, maintainable, and properly documented.

package/dist/chunk-1rptg3yg.js

@@ -0,0 +1,4 @@
+import"./chunk-sxy6vp20.js";import{AutoTokenizer as B}from"@huggingface/transformers";var Q=new Map,V=new Set,W=new Set,G=3,U={"gpt-4":"Xenova/gpt-4","gpt-4-turbo":"Xenova/gpt-4","gpt-4o":"Xenova/gpt-4","gpt-3.5-turbo":"Xenova/gpt-3.5-turbo","gpt-3.5":"Xenova/gpt-3.5-turbo","claude-3-opus":"Xenova/claude-tokenizer","claude-3-sonnet":"Xenova/claude-tokenizer","claude-3-haiku":"Xenova/claude-tokenizer","claude-3.5-sonnet":"Xenova/claude-tokenizer","claude-3.5-haiku":"Xenova/claude-tokenizer",starcoder:"bigcode/starcoder",starcoder2:"bigcode/starcoder2-3b",codellama:"codellama/CodeLlama-7b-hf",gemini:"Xenova/gpt-4",default:"Xenova/gpt-4"};function H(j){if(!j)return U.default;if(U[j])return U[j];let q=j.toLowerCase();for(let[J,P]of Object.entries(U))if(q.includes(J))return P;return U.default}function Y(j){if(!j)return 0;let q=j.split(/\s+/).filter(Boolean).length,J=j.length,P=Math.ceil(J/3.5),v=Math.ceil(q*1.3);return Math.round((P+v)/2)}async function S(j){let q=H(j);if(Q.has(q))return Q.get(q);if(W.has(q))return null;while(V.has(q))await new Promise((J)=>setTimeout(J,100));if(Q.has(q))return Q.get(q);if(W.has(q))return null;try{V.add(q);let J=await B.from_pretrained(q,{cache_dir:"./models/.cache",local_files_only:!1});if(Q.size>=G){let P=Q.keys().next().value;if(P)Q.delete(P)}return Q.set(q,J),V.delete(q),J}catch(J){return console.warn("[TokenCounter] BPE tokenizer initialization failed, using fallback estimation:",J),W.add(q),V.delete(q),null}}async function $(j,q){if(!j)return 0;let J=await S(q);if(!J)return Y(j);try{let P=await J(j);if(P.input_ids&&P.input_ids.size)return P.input_ids.size;if(Array.isArray(P.input_ids))return P.input_ids.length;if(P.input_ids.data)return P.input_ids.data.length;return Y(j)}catch(P){return console.warn("[TokenCounter] Token counting failed, using fallback:",P),Y(j)}}function X(j){return Y(j)}function p(j){if(j<1000)return j.toString();if(j<1e6)return`${(j/1000).toFixed(1)}K`;return`${(j/1e6).toFixed(1)}M`}async function y(j,q){return $(j,q)}async function A(j,q){let J=await $(j,q);return`${p(J)} Tokens`}function b(j){let q=X(j);return`${p(q)} Tokens`}async function f(j,q){return Promise.all(j.map((J)=>$(J,q)))}function D(j){return j.map(X)}async function L(j){let q=H(j),J=await S(j);return{modelName:j||"default",tokenizerName:q,loaded:J!==null,failed:W.has(q)}}function R(){return Object.keys(U).filter((j)=>j!=="default")}export{L as getTokenizerInfo,R as getSupportedModels,p as formatTokenCount,D as estimateTokensBatch,X as estimateTokens,y as countTokensForModel,f as countTokensBatch,$ as countTokens,b as countAndFormatSync,A as countAndFormat};
+export{p as t,L as u};
+
+//# debugId=0C9FB9C9D50392DD64756E2164756E21