gitx.do 0.0.2 → 0.1.0

package/README.md

@@ -1,16 +1,36 @@
 # gitx.do
 
-Git on Cloudflare Durable Objects - A complete Git reimplementation for the edge.
+**Git for Cloudflare Workers.** Full protocol. Edge-native. 5,600+ tests.
 
-## Features
+[![npm version](https://img.shields.io/npm/v/gitx.do.svg)](https://www.npmjs.com/package/gitx.do)
+[![Tests](https://img.shields.io/badge/tests-5%2C684%20passing-brightgreen.svg)](https://github.com/dot-do/gitx)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-blue.svg)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Why gitx?
+
+**AI agents need version control.** They generate code, iterate on files, need to track changes and roll back mistakes.
+
+**gitx is Git reimplemented for Cloudflare Workers.** Full protocol support - pack files, delta compression, smart HTTP. Not a wrapper around git CLI. A complete implementation.
+
+**Scales to millions of agents.** Each agent gets its own git repository on Cloudflare's edge network. No shared servers. No rate limits. Just fast, isolated version control at global scale.
+
+```typescript
+import git from 'gitx.do'
+
+// Initialize a repo
+await git.init('/my-project')
+
+// Stage and commit
+await git.add('/my-project', '.')
+await git.commit('/my-project', 'Initial commit')
 
-- **Pack Files** - Full Git packfile v2/v3 support with delta compression
-- **Wire Protocol** - Smart HTTP protocol implementation for fetch/push operations
-- **MCP Tools** - Model Context Protocol integration for AI-assisted git operations
-- **Tiered Storage** - Hot/warm/cold storage tiers with automatic promotion
-  - Hot: Durable Object SQLite (low latency)
-  - Warm: R2 object storage (packed objects)
-  - Cold: Analytics/Parquet (cold storage)
+// Branch and merge
+await git.branch('/my-project', 'feature')
+await git.checkout('/my-project', 'feature')
+// ... make changes ...
+await git.merge('/my-project', 'feature')
+```
 
 ## Installation
 
@@ -20,137 +40,344 @@ npm install gitx.do
 
 ## Quick Start
 
-### Pack Index Operations
+```typescript
+import git from 'gitx.do'
+
+// Create a repository
+await git.init('/repo')
+
+// Write files and commit
+await git.add('/repo', 'README.md')
+await git.commit('/repo', 'Add readme')
+
+// View history
+const log = await git.log('/repo')
+console.log(log.commits)
+
+// Create branches
+await git.branch('/repo', 'feature/auth')
+await git.checkout('/repo', 'feature/auth')
+
+// View changes
+const diff = await git.diff('/repo', 'main', 'feature/auth')
+const status = await git.status('/repo')
+```
+
+## Features
+
+### Full Git Protocol
+
+Complete implementation of Git internals:
 
 ```typescript
-import { parsePackIndex, createPackIndex, lookupObject } from 'gitx.do/pack'
+// Object model
+await git.hashObject('/repo', content, 'blob')
+await git.catFile('/repo', sha, 'blob')
 
-// Parse an existing pack index
-const index = parsePackIndex(indexData)
-console.log(`Pack contains ${index.objectCount} objects`)
+// Trees and commits
+const tree = await git.writeTree('/repo')
+const commit = await git.commitTree('/repo', tree, 'message', [parent])
 
-// Look up an object by SHA
-const entry = lookupObject(index, 'abc123...')
-if (entry) {
-  console.log(`Object at offset ${entry.offset}`)
-}
+// Pack files
+await git.pack('/repo', objects)
+await git.unpack('/repo', packData)
+
+// References
+await git.updateRef('/repo', 'refs/heads/main', sha)
+const ref = await git.resolveRef('/repo', 'HEAD')
+```
+
+### Tiered Storage
 
-// Create a new pack index
-const newIndex = createPackIndex({ packData })
+Hot objects in SQLite. Pack files in R2. You don't think about it.
+
+```
+┌────────────────────────────────────────────────────────┐
+│   Hot Tier (SQLite)           │   Warm Tier (R2)       │
+├───────────────────────────────┼────────────────────────┤
+│   • Recent commits            │   • Pack files         │
+│   • Active branches           │   • Full history       │
+│   • Loose objects             │   • Large blobs        │
+│   • <10ms access              │   • <100ms access      │
+└───────────────────────────────┴────────────────────────┘
 ```
 
-### Smart HTTP Protocol
+### Pack File Engine
+
+Full packfile v2/v3 support:
 
 ```typescript
-import { handleInfoRefs, handleUploadPack, handleReceivePack } from 'gitx.do/wire/smart-http'
+// Delta compression
+await git.repack('/repo', { deltify: true })
 
-// Handle ref discovery
-const response = await handleInfoRefs(request, repository, {
-  sideBand64k: true,
-  ofsDelta: true
-})
+// Verify integrity
+await git.fsck('/repo')
+
+// Garbage collection
+await git.gc('/repo')
+```
 
-// Handle fetch
-const packResponse = await handleUploadPack(request, repository)
+- OFS_DELTA and REF_DELTA compression
+- Multi-pack indexes (MIDX)
+- CRC32 verification
+- Thin pack support for network transfer
 
-// Handle push
-const pushResponse = await handleReceivePack(request, repository)
+### Wire Protocol
+
+Smart HTTP protocol for git clients:
+
+```typescript
+// Serve git fetch/push
+app.all('/repo.git/*', (req) => git.serve(req))
+
+// Clone works
+// git clone https://your-worker.dev/repo.git
+```
+
+- Capability negotiation
+- Side-band progress reporting
+- Multi-ack for efficiency
+- Shallow clone support
+
+### Merge & Diff
+
+Full three-way merge with conflict detection:
+
+```typescript
+// Merge branches
+const result = await git.merge('/repo', 'feature')
+if (result.conflicts) {
+  console.log('Conflicts:', result.conflicts)
+}
+
+// View diff
+const diff = await git.diff('/repo', 'main', 'feature')
+for (const file of diff.files) {
+  console.log(file.path, file.additions, file.deletions)
+}
+```
+
+### CLI Commands
+
+Full command-line interface:
+
+```typescript
+import { cli } from 'gitx.do/cli'
+
+await cli('init /repo')
+await cli('add /repo .')
+await cli('commit /repo -m "message"')
+await cli('log /repo --oneline')
+await cli('branch /repo feature')
+await cli('checkout /repo feature')
+await cli('merge /repo main')
+await cli('status /repo')
+await cli('diff /repo')
 ```
 
 ### MCP Tools
 
+Model Context Protocol for AI agents:
+
 ```typescript
-import { gitTools, invokeTool, registerTool } from 'gitx.do/mcp/tools'
+import { gitTools, invokeTool } from 'gitx.do/mcp'
 
-// List available git tools
-console.log(gitTools.map(t => t.name))
-// ['git_status', 'git_log', 'git_diff', 'git_commit', ...]
+// Available tools
+// git_init, git_add, git_commit, git_log, git_diff, git_status,
+// git_branch, git_checkout, git_merge, git_show, git_blame
 
-// Invoke a tool
-const result = await invokeTool('git_status', { path: '/repo', short: true })
+await invokeTool('git_commit', {
+  repo: '/my-project',
+  message: 'Fix authentication bug'
+})
 
-// Register a custom tool
-registerTool({
-  name: 'my_tool',
-  description: 'Custom git operation',
-  inputSchema: { type: 'object', properties: {} },
-  handler: async (params) => ({ content: [{ type: 'text', text: 'Done' }] })
+await invokeTool('git_log', {
+  repo: '/my-project',
+  limit: 10
 })
 ```
 
-### Tiered Storage
+## Durable Object Integration
+
+### As a Standalone DO
 
 ```typescript
-import { TieredReader } from 'gitx.do/tiered/read-path'
+import { GitDO } from 'gitx.do/do'
 
-const reader = new TieredReader(hotBackend, warmBackend, coldBackend, {
-  hot: { enabled: true, maxSize: 1024 * 1024 },
-  warm: { enabled: true },
-  cold: { enabled: true },
-  promotionPolicy: 'aggressive'
-})
+export { GitDO }
 
-// Read with automatic tier fallback and promotion
-const result = await reader.read(sha)
-console.log(`Found in ${result.tier} tier, latency: ${result.latencyMs}ms`)
+export default {
+  async fetch(request, env) {
+    const id = env.GIT.idFromName('repo-123')
+    const stub = env.GIT.get(id)
+    return stub.fetch(request)
+  }
+}
 ```
 
-### R2 Pack Storage
+### With dotdo Framework
 
 ```typescript
-import { R2PackStorage } from 'gitx.do/storage/r2-pack'
+import { DO } from 'dotdo'
+import { withGit } from 'gitx.do/do'
 
-const storage = new R2PackStorage({ bucket, prefix: 'repos/my-repo/' })
+class MyAgent extends withGit(DO) {
+  async work() {
+    await this.$.git.add('.', 'src/')
+    await this.$.git.commit('.', 'Update source files')
 
-// Upload a packfile
-const result = await storage.uploadPackfile(packData, indexData)
+    const log = await this.$.git.log('.')
+    return log.commits[0]
+  }
+}
+```
 
-// Download with verification
-const pack = await storage.downloadPackfile(packId, { verify: true })
+### As RPC Service
 
-// Use multi-pack index for cross-pack lookups
-await storage.rebuildMultiPackIndex()
-const midx = await storage.getMultiPackIndex()
+```toml
+# wrangler.toml
+[[services]]
+binding = "GITX"
+service = "gitx-worker"
 ```
 
-## API Overview
+```typescript
+await env.GITX.commit('/repo', 'message')
+```
+
+## API Reference
+
+### Repository Operations
+
+| Method | Description |
+|--------|-------------|
+| `init(path)` | Initialize new repository |
+| `clone(url, path)` | Clone remote repository |
+| `status(path)` | Get working tree status |
+| `log(path, options?)` | View commit history |
+
+### Staging & Commits
 
-### Pack Module (`gitx.do/pack`)
+| Method | Description |
+|--------|-------------|
+| `add(path, files)` | Stage files |
+| `commit(path, message)` | Create commit |
+| `reset(path, ref)` | Reset to commit |
 
-- `parsePackIndex(data)` - Parse a pack index file
-- `createPackIndex(options)` - Create a new pack index
-- `lookupObject(index, sha)` - Find object by SHA in index
-- `verifyPackIndex(data)` - Verify index integrity
-- `calculateCRC32(data)` - Compute CRC32 checksum
+### Branches & Merging
 
-### Wire Protocol (`gitx.do/wire`)
+| Method | Description |
+|--------|-------------|
+| `branch(path, name)` | Create branch |
+| `checkout(path, ref)` | Switch branches |
+| `merge(path, branch)` | Merge branch |
+| `rebase(path, onto)` | Rebase branch |
 
-- `handleInfoRefs()` - Ref discovery endpoint
-- `handleUploadPack()` - Fetch data transfer
-- `handleReceivePack()` - Push data transfer
-- `formatRefAdvertisement()` - Format ref list
-- `parseCapabilities()` - Parse protocol capabilities
+### Diff & Blame
 
-### MCP Tools (`gitx.do/mcp`)
+| Method | Description |
+|--------|-------------|
+| `diff(path, a, b)` | Compare commits |
+| `blame(path, file)` | Line-by-line history |
+| `show(path, ref)` | Show commit details |
 
-- `gitTools` - Array of available git tool definitions
-- `invokeTool(name, params)` - Execute a tool by name
-- `registerTool(tool)` - Add a custom tool
-- `validateToolInput(tool, params)` - Validate parameters
+### Low-Level
+
+| Method | Description |
+|--------|-------------|
+| `hashObject(path, data, type)` | Create object |
+| `catFile(path, sha, type)` | Read object |
+| `updateRef(path, ref, sha)` | Update reference |
+| `pack(path, objects)` | Create packfile |
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                      gitx.do                            │
+├─────────────────────────────────────────────────────────┤
+│  Git Commands (add, commit, branch, merge, etc.)        │
+├─────────────────────────────────────────────────────────┤
+│  Object Model (blob, tree, commit, tag)                 │
+├─────────────────────────────────────────────────────────┤
+│  Pack Engine (delta, compression, indexes)              │
+├────────────────────┬────────────────────────────────────┤
+│   Hot Tier         │         Warm Tier                  │
+│   (SQLite)         │         (R2)                       │
+│                    │                                    │
+│   • Loose objects  │   • Pack files                     │
+│   • References     │   • Large blobs                    │
+│   • Index          │   • Archive                        │
+└────────────────────┴────────────────────────────────────┘
+```
 
-### Tiered Storage (`gitx.do/tiered`)
+## Comparison
 
-- `TieredReader` - Multi-tier read path with promotion
-- `StoredObject` - Object representation
-- `TieredStorageConfig` - Configuration options
+| Feature | GitHub | GitLab | gitx.do |
+|---------|--------|--------|---------|
+| **Pricing** | $21/user/month | $29/user/month | Self-hosted |
+| **Storage** | 1GB free | 5GB free | R2 (cheap) |
+| **LFS bandwidth** | $0.0875/GB | Metered | R2 (no egress) |
+| **Full protocol** | Yes | Yes | Yes |
+| **Edge-native** | No | No | Yes |
+| **AI-native API** | No | No | Yes |
+| **Self-hosted** | Enterprise only | Complex | One-click |
 
-### R2 Storage (`gitx.do/storage`)
+## Use Cases
 
-- `R2PackStorage` - Packfile management for R2
-- `uploadPackfile()` - Store pack and index
-- `downloadPackfile()` - Retrieve with optional verification
-- `createMultiPackIndex()` - Build cross-pack index
+### AI Agent Version Control
+
+Each AI agent gets its own repository:
+
+```typescript
+class CodeAgent extends withGit(DO) {
+  async generateCode(spec) {
+    const code = await this.ai.generate(spec)
+
+    await this.$.fs.writeFile('src/index.ts', code)
+    await this.$.git.add('.', 'src/')
+    await this.$.git.commit('.', `Implement: ${spec}`)
+
+    return this.$.git.log('.', { limit: 1 })
+  }
+}
+```
+
+### Private Git Hosting
+
+Your repositories on your infrastructure:
+
+```typescript
+export default GitX({
+  name: 'my-repos',
+  domain: 'git.mycompany.com',
+})
+```
+
+### LFS Without Bandwidth Fees
+
+R2 has no egress charges:
+
+```typescript
+await git.lfsTrack('/repo', '*.psd')
+await git.lfsPush('/repo')
+```
+
+## Performance
+
+- **5,684 tests** covering all operations
+- **Full Git protocol** - clone, fetch, push all work
+- **<10ms** for hot tier operations
+- **Global edge** - 300+ Cloudflare locations
+- **Zero cold starts** - Durable Objects
 
 ## License
 
 MIT
+
+## Links
+
+- [GitHub](https://github.com/dot-do/gitx)
+- [Documentation](https://gitx.do)
+- [.do](https://do.org.ai)
+- [Platform.do](https://platform.do)

package/dist/cli/commands/add.d.ts

@@ -0,0 +1,174 @@
+/**
+ * @fileoverview gitx add command
+ *
+ * This module implements the `gitx add` command which adds files to the
+ * staging area (index). It supports:
+ * - Adding single files
+ * - Adding multiple files
+ * - Adding directories recursively
+ * - Glob pattern matching
+ * - Adding all files (-A or --all)
+ * - Updating tracked files only (-u or --update)
+ * - Dry run mode (-n or --dry-run)
+ * - Verbose output (-v or --verbose)
+ *
+ * @module cli/commands/add
+ *
+ * @example
+ * // Add a single file
+ * await addFiles(cwd, ['file.txt'])
+ *
+ * @example
+ * // Add all files
+ * await addAll(cwd)
+ *
+ * @example
+ * // Dry run to see what would be added
+ * await addDryRun(cwd, ['*.ts'])
+ */
+import type { CommandContext } from '../index';
+/**
+ * Options for the add command.
+ *
+ * @description Configuration options that control the behavior
+ * of the add command.
+ */
+export interface AddOptions {
+    /** Force add ignored files */
+    force?: boolean;
+    /** Show what would be added without actually adding */
+    dryRun?: boolean;
+    /** Show verbose output */
+    verbose?: boolean;
+    /** Record only the fact that the path will be added later */
+    intentToAdd?: boolean;
+    /** Update tracked files only (like git add -u) */
+    update?: boolean;
+    /** Add all files including untracked (like git add -A) */
+    all?: boolean;
+    /** Exclude patterns */
+    exclude?: string[];
+    /** Refresh index stat information */
+    refresh?: boolean;
+    /** Interactive patch mode */
+    patch?: boolean;
+}
+/**
+ * Result of an add operation.
+ *
+ * @description Contains lists of files that were added, deleted,
+ * or unchanged, plus detailed file information.
+ */
+export interface AddResult {
+    /** Files that were successfully added to the index */
+    added: string[];
+    /** Files that were staged for deletion */
+    deleted: string[];
+    /** Files that were already staged with no changes */
+    unchanged: string[];
+    /** Files that would be added (for dry-run mode) */
+    wouldAdd: string[];
+    /** Files marked as intent-to-add */
+    intentToAdd: string[];
+    /** Detailed file information */
+    files: FileToAdd[];
+    /** Total count of files affected */
+    count: number;
+}
+/**
+ * Information about a file to be added.
+ *
+ * @description Contains the path, computed SHA, and file mode
+ * for a file being staged.
+ */
+export interface FileToAdd {
+    /** File path relative to repository root */
+    path: string;
+    /** SHA-1 hash of the file content */
+    sha: string;
+    /** File mode (100644 for regular, 100755 for executable, 120000 for symlink) */
+    mode: number;
+}
+/**
+ * Handler for the gitx add command.
+ *
+ * @description Processes command-line arguments and adds files to the staging area.
+ *
+ * @param ctx - Command context with cwd, args, options
+ * @throws Error if not in a git repository or files not found
+ */
+export declare function addCommand(ctx: CommandContext): Promise<void>;
+/**
+ * Add specified files to the staging area.
+ *
+ * @description Adds the given files or patterns to the git index.
+ * Supports glob patterns and directories.
+ *
+ * @param cwd - Working directory (repository root)
+ * @param paths - File paths or patterns to add
+ * @param options - Add options
+ * @returns AddResult with added files information
+ * @throws Error if not in a git repository or files not found
+ */
+export declare function addFiles(cwd: string, paths: string[], options?: AddOptions): Promise<AddResult>;
+/**
+ * Add all files to the staging area (like git add -A).
+ *
+ * @description Adds all untracked, modified, and deleted files
+ * to the staging area.
+ *
+ * @param cwd - Working directory (repository root)
+ * @param options - Add options
+ * @returns AddResult with added files information
+ * @throws Error if not in a git repository
+ */
+export declare function addAll(cwd: string, options?: AddOptions): Promise<AddResult>;
+/**
+ * Update tracked files only (like git add -u).
+ *
+ * @description Stages modifications and deletions of tracked files only.
+ * Does not add untracked files.
+ *
+ * @param cwd - Working directory (repository root)
+ * @param options - Add options
+ * @returns AddResult with updated files information
+ * @throws Error if not in a git repository
+ */
+export declare function addUpdate(cwd: string, options?: AddOptions): Promise<AddResult>;
+/**
+ * Dry run to show what would be added.
+ *
+ * @description Shows what files would be added without actually
+ * modifying the index.
+ *
+ * @param cwd - Working directory (repository root)
+ * @param paths - File paths or patterns to check
+ * @param options - Add options
+ * @returns AddResult with wouldAdd populated
+ * @throws Error if not in a git repository
+ */
+export declare function addDryRun(cwd: string, paths: string[], options?: AddOptions): Promise<AddResult>;
+/**
+ * Get list of files that would be added for given paths.
+ *
+ * @description Resolves paths and glob patterns to a list of files
+ * that would be added to the index.
+ *
+ * @param cwd - Working directory (repository root)
+ * @param paths - File paths or patterns
+ * @param options - Add options including exclude patterns
+ * @returns Array of FileToAdd objects
+ * @throws Error if not in a git repository
+ */
+export declare function getFilesToAdd(cwd: string, paths: string[], options?: AddOptions): Promise<FileToAdd[]>;
+/**
+ * Match a file path against a glob pattern.
+ *
+ * @description Utility function to test if a path matches a glob pattern.
+ *
+ * @param filePath - File path to test
+ * @param pattern - Glob pattern to match against
+ * @returns true if the path matches the pattern
+ */
+export declare function matchGlobPattern(filePath: string, pattern: string): boolean;
+//# sourceMappingURL=add.d.ts.map

package/dist/cli/commands/add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/add.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAM9C;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,8BAA8B;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,uDAAuD;IACvD,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,0BAA0B;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,6DAA6D;IAC7D,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,kDAAkD;IAClD,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,0DAA0D;IAC1D,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,uBAAuB;IACvB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,qCAAqC;IACrC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,6BAA6B;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,sDAAsD;IACtD,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,0CAA0C;IAC1C,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,qDAAqD;IACrD,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,mDAAmD;IACnD,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,oCAAoC;IACpC,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,gCAAgC;IAChC,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAA;IACZ,qCAAqC;IACrC,GAAG,EAAE,MAAM,CAAA;IACX,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;CACb;AAMD;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAEnE;AAMD;;;;;;;;;;;GAWG;AACH,wBAAsB,QAAQ,CAC5B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,SAAS,CAAC,CAEpB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,MAAM,CAC1B,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,SAAS,CAAC,CAEpB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,SAAS,CAAC,CAEpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,SAAS,CAAC,CAEpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,SAAS,EAAE,CAAC,CAEtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE3E"}