everything-gemini 1.2.0 → 1.9.0

package/skills/turborepo-monorepo/SKILL.md

@@ -0,0 +1,199 @@
+---
+name: turborepo-monorepo
+description: >-
+  Architects, configures, and optimizes high-performance monorepo build systems using Turborepo, fine-grained task pipelines (turbo.json), remote caching, package boundary isolation, and Docker pruning.
+---
+
+# Turborepo Monorepo Architecture & Task Pipelines
+
+This skill guides structuring, optimizing, and maintaining multi-package JavaScript/TypeScript monorepos with Turborepo, leveraging incremental computation, hash-based task caching, remote cache synchronization, and isolated Docker container pruning.
+
+---
+
+## ⚡ Core Patterns
+
+### 1. Production `turbo.json` Pipeline Specification
+
+Define task dependencies, input hashes, cache retention, and environment variable tracking in root `turbo.json`:
+
+```json
+{
+  "$schema": "https://turbo.build/schema.json",
+  "ui": "tui",
+  "tasks": {
+    "topo": {
+      "dependsOn": ["^topo"]
+    },
+    "build": {
+      "dependsOn": ["^build"],
+      "inputs": ["$TURBO_DEFAULT$", ".env*", "!**/*.test.*"],
+      "outputs": [".next/**", "!.next/cache/**", "dist/**", "build/**"],
+      "env": ["NODE_ENV", "NEXT_PUBLIC_*", "API_BASE_URL"]
+    },
+    "test": {
+      "dependsOn": ["build"],
+      "inputs": ["src/**/*.tsx", "src/**/*.ts", "test/**/*.ts"],
+      "outputs": ["coverage/**"]
+    },
+    "lint": {
+      "dependsOn": ["^topo"],
+      "outputs": []
+    },
+    "dev": {
+      "cache": false,
+      "persistent": true
+    },
+    "typecheck": {
+      "dependsOn": ["^build"],
+      "outputs": []
+    }
+  },
+  "globalEnv": ["CI", "PORT"],
+  "globalDependencies": [
+    "tsconfig.base.json",
+    ".eslintrc.js",
+    "pnpm-lock.yaml"
+  ]
+}
+```
+
+---
+
+### 2. Monorepo Workspace Directory Structure
+
+Maintain strict package boundaries between deployable applications (`apps/*`) and shared internal libraries (`packages/*`):
+
+```text
+my-monorepo/
+├── apps/
+│   ├── web/                     # Next.js / SvelteKit / React SPA
+│   │   ├── package.json
+│   │   └── tsconfig.json
+│   └── api/                     # Node.js / Express / Nest / Fastify
+│       ├── package.json
+│       └── tsconfig.json
+├── packages/
+│   ├── ui/                      # Shared React design system
+│   ├── database/                # Drizzle / Prisma / SQL migrations
+│   ├── config-eslint/           # Internal shared ESLint rules
+│   └── config-typescript/       # tsconfig.base.json definitions
+├── turbo.json                   # Pipeline DAG orchestration
+├── pnpm-workspace.yaml          # Package manager workspaces
+└── package.json                 # Root scripts and dev dependencies
+```
+
+---
+
+### 3. Internal Package Definition with `package.json` Exports
+
+Configure shared internal libraries using modern TypeScript `exports` without premature bundler compilation:
+
+```json
+{
+  "name": "@workspace/ui",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    "./button": {
+      "types": "./src/button.tsx",
+      "default": "./src/button.tsx"
+    },
+    "./theme": {
+      "types": "./src/theme.ts",
+      "default": "./src/theme.ts"
+    }
+  },
+  "scripts": {
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@workspace/config-typescript": "workspace:*",
+    "typescript": "^5.4.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0"
+  }
+}
+```
+
+---
+
+### 4. Remote Caching & CI/CD Acceleration
+
+Enable zero-redundancy CI builds with Vercel or self-hosted Remote Cache (e.g. AWS S3 or MinIO):
+
+```bash
+# 1. Authenticate with remote cache provider
+npx turbo login
+
+# 2. Link repository to team space
+npx turbo link
+
+# 3. In CI environments, provide token and team identifier via environment
+export TURBO_TOKEN="your-cache-secret-token"
+export TURBO_TEAM="your-team-slug"
+
+# 4. Run targeted pipeline with cache hit verification
+turbo run build test lint --filter=...[origin/main]
+```
+
+---
+
+### 5. Multi-Stage Docker Build Optimization via `turbo prune`
+
+Generate a minimal build context containing only the target application and its direct internal dependencies:
+
+```dockerfile
+# Stage 1: Prune monorepo for target app
+FROM node:20-alpine AS pruner
+RUN apk add --no-cache libc6-compat
+WORKDIR /app
+RUN npm install -g turbo
+COPY . .
+RUN turbo prune web --docker
+
+# Stage 2: Install dependencies from pruned lockfile
+FROM node:20-alpine AS installer
+RUN apk add --no-cache libc6-compat
+WORKDIR /app
+COPY .gitignore .gitignore
+COPY --from=pruner /app/out/json/ .
+COPY --from=pruner /app/out/pnpm-lock.yaml ./pnpm-lock.yaml
+RUN corepack enable && pnpm install --frozen-lockfile
+
+# Stage 3: Build application
+COPY --from=pruner /app/out/full/ .
+COPY turbo.json turbo.json
+RUN pnpm turbo run build --filter=web...
+
+# Stage 4: Production Runner
+FROM node:20-alpine AS runner
+WORKDIR /app
+ENV NODE_ENV=production
+RUN addgroup --system --gid 1001 nodejs && adduser --system --uid 1001 nextjs
+COPY --from=installer --chown=nextjs:nodejs /app/apps/web/.next/standalone ./
+COPY --from=installer --chown=nextjs:nodejs /app/apps/web/.next/static ./apps/web/.next/static
+USER nextjs
+EXPOSE 3000
+CMD ["node", "apps/web/server.js"]
+```
+
+---
+
+## 🎯 Verification & Diagnostics
+
+1. **Inspect Task Graph**:
+   ```bash
+   turbo run build --graph=build-graph.html
+   ```
+2. **Dry Run Pipeline**:
+   ```bash
+   turbo run test --dry-run
+   ```
+3. **Targeted Subtree Execution**:
+   ```bash
+   turbo run build --filter=web...   # web and all its internal dependencies
+   turbo run test --filter=...api    # api and all packages that depend on it
+   ```

package/skills/vault-secrets-management/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: vault-secrets-management
+description: >-
+  Architects and automates HashiCorp Vault secrets management, AppRole machine authentication, dynamic ephemeral database credentials, and PKI mTLS certificate rotation.
+---
+
+# HashiCorp Vault Secrets Management & Ephemeral Credentials
+
+This skill guides the design, automation, and operational patterns for HashiCorp Vault enterprise secrets orchestration, dynamic credential generation, and PKI certificate authority workflows.
+
+---
+
+## ⚡ Secret Engine Capabilities Matrix
+
+| Secret Engine | Purpose | Lifecycle Behavior |
+| :--- | :--- | :--- |
+| **`kv-v2`** | Static credentials & API keys | Versioned key-value store with soft delete and rollback. |
+| **`database`** | Ephemeral DB access (Postgres, MySQL) | Generates short-lived user credentials and revokes upon lease expiry. |
+| **`pki`** | Internal mTLS & TLS certificates | Acts as CA/sub-CA; dynamically issues certificates in milliseconds. |
+| **`transit`** | Cryptography as a service | Encrypts/decrypts data without exposing raw encryption keys. |
+
+---
+
+## 🔐 AppRole Machine Authentication Workflow
+
+Applications authenticate using decoupled `role_id` and short-lived `secret_id`:
+
+```bash
+# 1. Enable AppRole auth method
+vault auth enable approle
+
+# 2. Configure service role with strict CIDR and token policies
+vault write auth/approle/role/api-service \
+    secret_id_ttl=60m \
+    token_ttl=30m \
+    token_max_ttl=4h \
+    secret_id_num_uses=10 \
+    token_policies="api-service-policy" \
+    bind_secret_id=true
+
+# 3. Retrieve Role ID (stored in deployment manifest)
+vault read auth/approle/role/api-service/role-id
+
+# 4. Generate Secret ID (delivered securely via CI/CD or orchestrator)
+vault write -f auth/approle/role/api-service/secret-id
+```
+
+Node.js / Python authentication client:
+
+```typescript
+import axios from 'axios';
+
+export async function loginWithAppRole(vaultAddr: string, roleId: string, secretId: string) {
+  const response = await axios.post(`${vaultAddr}/v1/auth/approle/login`, {
+    role_id: roleId,
+    secret_id: secretId,
+  });
+  
+  const clientToken = response.data.auth.client_token;
+  const leaseDuration = response.data.auth.lease_duration;
+  return { clientToken, leaseDuration };
+}
+```
+
+---
+
+## ⏳ Dynamic Ephemeral Database Credentials
+
+Configure Vault to create temporary, unique PostgreSQL roles for each application instance:
+
+```bash
+# 1. Mount database engine
+vault secrets enable database
+
+# 2. Configure connection to PostgreSQL
+vault write database/config/production-postgres \
+    plugin_name=postgresql-database-plugin \
+    allowed_roles="readwrite-service" \
+    connection_url="postgresql://{{username}}:{{password}}@postgres:5432/production?sslmode=verify-full" \
+    username="vaultadmin" \
+    password="supersecretadminpassword"
+
+# 3. Define role template with automated role creation SQL
+vault write database/roles/readwrite-service \
+    db_name=production-postgres \
+    creation_statements="CREATE ROLE \"{{name}}\" WITH LOGIN PASSWORD '{{password}}' VALID UNTIL '{{expiration}}'; \
+        GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO \"{{name}}\";" \
+    default_ttl="1h" \
+    max_ttl="24h"
+```
+
+Application requests credentials on demand:
+
+```bash
+vault read database/creds/readwrite-service
+# Returns: username: v-approle-readwrite-abc123, password: xyz..., lease_id: database/creds/readwrite-service/xyz...
+```
+
+---
+
+## 📜 PKI Dynamic mTLS Certificate Issuance
+
+Automate TLS certificate issuance without manual CSR handling:
+
+```bash
+# Mount PKI engine and configure Root/Intermediate CA
+vault secrets enable pki
+vault secrets tune -max-lease-ttl=87600h pki
+
+# Configure role for cluster services
+vault write pki/roles/internal-mesh \
+    allowed_domains="internal.cluster.local" \
+    allow_subdomains=true \
+    max_ttl="72h"
+
+# Generate certificate on demand
+vault write pki/issue/internal-mesh \
+    common_name="billing-service.internal.cluster.local" \
+    ttl="24h"
+```
+
+---
+
+## 📋 Architectural Rules & Best Practices
+
+1. **Never Hardcode Secrets**: Eliminate long-lived static DB passwords; adopt dynamic ephemeral database roles with short TTLs (< 2 hours).
+2. **Strict Secret ID Binding**: Bind AppRole `secret_id` to expected subnet CIDRs (`secret_id_bound_cidrs`) to stop credential theft across VPCs.
+3. **Lease Renewal & Heartbeats**: Background workers must periodically renew active leases (`vault write sys/leases/renew lease_id=...`) before expiry.
+4. **Audit Logging**: Enable Vault audit devices (`vault audit enable file file_path=/var/log/vault/audit.log`) with hashed payload sanitization.

package/skills/vllm-inference/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: vllm-inference
+description: >-
+  High-throughput LLM serving and inference optimization using vLLM, PagedAttention memory management, continuous batching, tensor parallelism, and OpenAI-compatible API architecture. Use when deploying open-weights models, optimizing GPU KV caches, scaling Ray clusters, or tuning inference throughput.
+---
+
+# vLLM Inference & Serving Architecture
+
+A comprehensive runbook for deploying, tuning, and operating enterprise LLM inference infrastructure using **vLLM**, PagedAttention, and distributed GPU clusters.
+
+---
+
+## 🎯 Architectural Principles
+
+1. **PagedAttention**: Near-zero memory waste by allocating KV cache in non-contiguous physical blocks (virtual memory paging for LLMs).
+2. **Continuous (Iteration-Level) Batching**: Requests join and exit the running batch dynamically at token generation boundaries rather than waiting for sequence completion.
+3. **Tensor & Pipeline Parallelism**: Seamless multi-GPU sharding using Megatron-LM style tensor parallelism across NVLink or distributed Ray nodes.
+4. **OpenAI Protocol Parity**: Fully compliant Drop-in replacement for Chat Completions, Completions, and Embedding endpoints.
+
+---
+
+## 🚀 Quickstart: Production Deployment
+
+### 1. Standalone Docker Container Deployment
+
+```bash
+docker run --gpus all \
+  --shm-size 10.24gb \
+  -p 8000:8000 \
+  -v ~/.cache/huggingface:/root/.cache/huggingface \
+  --ipc=host \
+  vllm/vllm-openai:latest \
+  --model Qwen/Qwen2.5-72B-Instruct-AWQ \
+  --tensor-parallel-size 4 \
+  --max-model-len 32768 \
+  --gpu-memory-utilization 0.92 \
+  --kv-cache-dtype auto \
+  --enable-chunked-prefill \
+  --max-num-seqs 256
+```
+
+### 2. High-Performance Configuration Matrix
+
+| Parameter | Recommended Setting | Architectural Rationale |
+| :--- | :--- | :--- |
+| `--gpu-memory-utilization` | `0.90` - `0.95` | Leaves ~5-10% GPU VRAM for CUDA context and PyTorch allocator overhead. |
+| `--tensor-parallel-size` | Matches socket count (2, 4, 8) | Shards attention heads evenly across NVLink interconnects. |
+| `--enable-chunked-prefill` | `true` | Prevents long prompt prefill passes from blocking decode iterations of active requests. |
+| `--max-num-batched-tokens` | `4096` - `8192` | Balances prefill compute intensity with KV cache allocation throughput. |
+| `--kv-cache-dtype` | `fp8` / `auto` | Halves KV memory consumption on Ada/Hopper architectures (H100/L40S). |
+
+---
+
+## 🛠️ Python SDK Integration
+
+Interact with vLLM via either offline batch processing or the OpenAI client.
+
+### Pattern A: Offline High-Throughput Batch Processing
+
+```python
+from vllm import LLM, SamplingParams
+
+# Configure model engine with tensor parallelism
+llm = LLM(
+    model="mistralai/Mistral-7B-Instruct-v0.3",
+    tensor_parallel_size=2,
+    gpu_memory_utilization=0.90,
+    max_model_len=16384,
+    trust_remote_code=True,
+)
+
+sampling_params = SamplingParams(
+    temperature=0.7,
+    top_p=0.95,
+    max_tokens=1024,
+    presence_penalty=0.1,
+)
+
+prompts = [
+    "Analyze the following architectural bottleneck: ...",
+    "Generate a Terraform module for Cilium eBPF on GKE: ...",
+]
+
+outputs = llm.generate(prompts, sampling_params)
+
+for output in outputs:
+    prompt = output.prompt
+    generated_text = output.outputs[0].text
+    print(f"Generated {len(output.outputs[0].token_ids)} tokens.")
+```
+
+### Pattern B: Async OpenAI Client Integration
+
+```python
+from openai import AsyncOpenAI
+import asyncio
+
+client = AsyncOpenAI(
+    base_url="http://localhost:8000/v1",
+    api_key="token-internal-vllm",
+)
+
+async def stream_generation(prompt: str):
+    response = await client.chat.completions.create(
+        model="Qwen/Qwen2.5-72B-Instruct-AWQ",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.2,
+        stream=True,
+    )
+    async for chunk in response:
+        delta = chunk.choices[0].delta.content or ""
+        print(delta, end="", flush=True)
+
+asyncio.run(stream_generation("Summarize the benefits of continuous batching."))
+```
+
+---
+
+## 📈 Prometheus Observability & Metrics
+
+vLLM exposes Prometheus metrics on `/metrics`:
+
+```text
+# Cache usage metrics
+vllm:gpu_cache_usage_factor        # Active KV cache allocation (target: < 0.85)
+vllm:num_requests_waiting          # Requests queued in prefill backlog (target: 0)
+vllm:num_requests_running          # Concurrently decoding requests
+vllm:time_to_first_token_seconds   # TTFT distribution histogram
+vllm:time_per_output_token_seconds # Inter-token generation latency (target: < 25ms)
+```
+
+---
+
+## 🛡️ Common Failure Modes & Mitigations
+
+1. **CUDA Out of Memory (OOM) during Startup**:
+   - *Cause*: Model weights + KV cache exceeds total VRAM.
+   - *Fix*: Reduce `--gpu-memory-utilization` from 0.95 to 0.88, or enforce AWQ/GPTQ 4-bit quantization.
+2. **Request Preemption Storms**:
+   - *Cause*: KV cache saturates (`gpu_cache_usage_factor = 1.0`), forcing vLLM to swap sequences to CPU memory.
+   - *Fix*: Reduce `--max-num-seqs` or enable `--kv-cache-dtype fp8` to double cache capacity.
+3. **TTFT Spikes on Long Contexts**:
+   - *Cause*: Large prompt prefills starving active decode steps.
+   - *Fix*: Pass `--enable-chunked-prefill` and `--max-num-batched-tokens 2048`.

package/skills/wasm-rust-optimizer/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: wasm-rust-optimizer
+description: >-
+  Compiles and optimizes high-performance WebAssembly modules from Rust using wasm-pack, zero-copy memory buffers (Uint8Array), SIMD vectorization, and Web Worker thread pools.
+---
+
+# WebAssembly & Rust Performance Optimization
+
+This skill guides compiling compute-intensive logic (image processing, cryptographic hashing, parser engines, physics calculations) into high-throughput WebAssembly (WASM) modules using Rust.
+
+---
+
+## ⚡ Rust & Cargo Configuration (`Cargo.toml`)
+
+Configure the crate for minimal binary footprint and direct browser bindings:
+
+```toml
+[package]
+name = "wasm-engine"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+wasm-bindgen = "0.2"
+js-sys = "0.3"
+web-sys = { version = "0.3", features = ["console"] }
+
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1
+panic = "abort"
+strip = true
+```
+
+---
+
+## 🚀 Zero-Copy Memory Transfer (Uint8Array)
+
+Avoid JSON serialization overhead when passing gigabytes or megabytes of data between JavaScript and WebAssembly. Pass memory buffer pointers directly:
+
+### 1. Rust Implementation (`src/lib.rs`)
+
+```rust
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub struct ImageProcessor {
+    buffer: Vec<u8>,
+}
+
+#[wasm_bindgen]
+impl ImageProcessor {
+    #[wasm_bindgen(constructor)]
+    pub fn new(size: usize) -> Self {
+        Self {
+            buffer: vec![0u8; size],
+        }
+    }
+
+    /// Exposes raw memory pointer for zero-copy JavaScript access
+    pub fn get_buffer_ptr(&self) -> *const u8 {
+        self.buffer.as_ptr()
+    }
+
+    /// In-place high-performance pixel grayscale filter
+    pub fn process_grayscale(&mut self) {
+        // Fast in-place chunk iteration
+        for pixel in self.buffer.chunks_exact_mut(4) {
+            let r = pixel[0] as u32;
+            let g = pixel[1] as u32;
+            let b = pixel[2] as u32;
+            let gray = ((r * 77 + g * 150 + b * 29) >> 8) as u8;
+            pixel[0] = gray;
+            pixel[1] = gray;
+            pixel[2] = gray;
+        }
+    }
+}
+```
+
+---
+
+### 2. JavaScript / TypeScript Client Integration
+
+```typescript
+import init, { ImageProcessor } from './pkg/wasm_engine.js';
+
+export async function runProcessor(canvas: HTMLCanvasElement) {
+  const wasm = await init();
+  const ctx = canvas.getContext('2d')!;
+  const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+  const totalBytes = imageData.data.length;
+
+  // Instantiate Rust WASM processor
+  const processor = new ImageProcessor(totalBytes);
+  const ptr = processor.get_buffer_ptr();
+
+  // Create zero-copy views directly into WASM linear memory
+  const wasmMemoryView = new Uint8Array(wasm.memory.buffer, ptr, totalBytes);
+  wasmMemoryView.set(imageData.data);
+
+  // Execute native compiled computation
+  processor.process_grayscale();
+
+  // Read back transformed memory without cloning
+  imageData.data.set(wasmMemoryView);
+  ctx.putImageData(imageData, 0, 0);
+}
+```
+
+---
+
+## 🛠️ Build & Optimization Workflow
+
+1. **Compile with `wasm-pack`:**
+   ```bash
+   wasm-pack build --target web --release
+   ```
+
+2. **Optimize with `wasm-opt` (Binaryen):**
+   ```bash
+   wasm-opt -O4 -o pkg/wasm_engine_bg_opt.wasm pkg/wasm_engine_bg.wasm
+   ```
+
+3. **Non-Blocking Compute in Web Workers:**
+   Always instantiate large WASM modules inside dedicated Web Workers (`new Worker(new URL('./worker.ts', import.meta.url))`) to keep the UI thread rendering at a silky 60/120 FPS.

package/templates/full-power/hooks.json

@@ -52,5 +52,19 @@
         ]
       }
     ]
+  },
+  "secret-scrubber": {
+    "PreToolUse": [
+      {
+        "matcher": "write_to_file|replace_file_content|multi_replace_file_content",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ./hooks/secret-scrubber/scripts/scrub-secrets.sh",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
   }
 }

package/templates/full-power/mcp_config.json

@@ -10,6 +10,53 @@
     "postgres": {
       "command": "npx",
       "args": ["-y", "@modelcontextprotocol/server-postgres", "${DATABASE_URL}"]
+    },
+    "memory": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-memory"]
+    },
+    "fetch": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-fetch"]
+    },
+    "redis": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-redis", "${REDIS_URL}"]
+    },
+    "docker": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-docker"]
+    },
+    "clickhouse": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-clickhouse", "${CLICKHOUSE_URL}"]
+    },
+    "sequential-thinking": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
+    },
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "./docs", "./src"]
+    },
+    "sentry": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-sentry"],
+      "env": {
+        "SENTRY_AUTH_TOKEN": "${SENTRY_AUTH_TOKEN}"
+      }
+    },
+    "slack": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-slack"],
+      "env": {
+        "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}",
+        "SLACK_TEAM_ID": "${SLACK_TEAM_ID}"
+      }
+    },
+    "puppeteer": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
     }
   }
 }

package/templates/recommended/hooks.json

@@ -39,5 +39,19 @@
         ]
       }
     ]
+  },
+  "secret-scrubber": {
+    "PreToolUse": [
+      {
+        "matcher": "write_to_file|replace_file_content|multi_replace_file_content",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ./hooks/secret-scrubber/scripts/scrub-secrets.sh",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
   }
 }