claudient 0.1.0

package/skills/database/graphql.md

@@ -0,0 +1,179 @@
+# GraphQL Skill
+
+## When to activate
+- Designing a GraphQL schema (types, queries, mutations, subscriptions)
+- Implementing resolvers in Node.js (Apollo Server, Pothos, GraphQL Yoga)
+- Setting up Prisma with a GraphQL API
+- Writing GraphQL queries and fragments for a frontend client
+- Implementing cursor-based or offset pagination in GraphQL
+- Setting up DataLoader for N+1 query prevention
+- Adding authentication and authorization to a GraphQL API
+- Debugging GraphQL performance or N+1 issues
+
+## When NOT to use
+- REST APIs where GraphQL adds complexity without benefit (simple CRUD, webhooks, file uploads)
+- gRPC or event-driven systems
+- Cases where the client always needs the full response (GraphQL's field selection adds no value)
+
+## Instructions
+
+### Schema design principles
+```graphql
+# Type names: PascalCase singular nouns
+# Field names: camelCase
+# Enums: SCREAMING_SNAKE_CASE values
+
+type Order {
+  id: ID!
+  status: OrderStatus!
+  customer: Customer!       # Nested type — always return the object, not just the ID
+  items: [OrderItem!]!     # Non-null list of non-null items
+  totalAmount: Float!
+  createdAt: DateTime!
+}
+
+enum OrderStatus {
+  PENDING
+  COMPLETED
+  CANCELLED
+}
+
+# Queries: return nullable for single item (not found = null), non-null for lists
+type Query {
+  order(id: ID!): Order       # Nullable — null if not found
+  orders(filter: OrderFilter): [Order!]!  # Non-null list
+  me: User                    # Nullable — null if not authenticated
+}
+
+# Mutations: always return the mutated object plus an errors array
+type Mutation {
+  createOrder(input: CreateOrderInput!): CreateOrderPayload!
+}
+
+type CreateOrderPayload {
+  order: Order          # Null if mutation failed
+  errors: [UserError!]! # Empty if successful
+}
+
+type UserError {
+  field: String
+  message: String!
+}
+```
+
+### N+1 prevention with DataLoader
+```typescript
+import DataLoader from 'dataloader';
+
+// Create per-request — never singleton (request data isolation)
+export function createLoaders() {
+  return {
+    customerLoader: new DataLoader<string, Customer>(async (ids) => {
+      const customers = await db.customer.findMany({
+        where: { id: { in: [...ids] } }
+      });
+      // Must return in same order as ids
+      const customerMap = new Map(customers.map(c => [c.id, c]));
+      return ids.map(id => customerMap.get(id) ?? new Error(`Customer ${id} not found`));
+    }),
+  };
+}
+
+// Resolver — uses loader, not direct DB call
+const resolvers = {
+  Order: {
+    customer: (order, _, { loaders }) => loaders.customerLoader.load(order.customerId),
+  }
+};
+```
+
+### Cursor-based pagination (preferred over offset)
+```graphql
+type OrderConnection {
+  edges: [OrderEdge!]!
+  pageInfo: PageInfo!
+  totalCount: Int!
+}
+
+type OrderEdge {
+  node: Order!
+  cursor: String!
+}
+
+type PageInfo {
+  hasNextPage: Boolean!
+  hasPreviousPage: Boolean!
+  startCursor: String
+  endCursor: String
+}
+
+type Query {
+  orders(first: Int, after: String, last: Int, before: String): OrderConnection!
+}
+```
+
+### Authorization pattern
+```typescript
+// Field-level authorization in resolver
+const resolvers = {
+  Query: {
+    adminStats: (_, __, { user }) => {
+      if (!user || user.role !== 'ADMIN') {
+        throw new GraphQLError('Unauthorized', {
+          extensions: { code: 'UNAUTHORIZED' }
+        });
+      }
+      return getAdminStats();
+    }
+  },
+  Order: {
+    // Object-level: only return sensitive fields to the order's owner
+    internalNotes: (order, _, { user }) => {
+      if (user?.id !== order.customerId && user?.role !== 'ADMIN') return null;
+      return order.internalNotes;
+    }
+  }
+};
+```
+
+### Prisma + GraphQL pattern
+```typescript
+// Resolver using Prisma — avoid over-fetching
+const resolvers = {
+  Query: {
+    order: async (_, { id }, { prisma, user }) => {
+      const order = await prisma.order.findUnique({
+        where: { id },
+        select: {
+          id: true,
+          status: true,
+          customerId: true,
+          totalAmount: true,
+          createdAt: true,
+          // Do NOT select items here — let the items resolver handle it
+          // with DataLoader to avoid N+1
+        }
+      });
+      if (!order) return null;
+      if (order.customerId !== user?.id) throw new GraphQLError('Forbidden');
+      return order;
+    }
+  }
+};
+```
+
+## Example
+
+**User:** Design a GraphQL schema and resolvers for a simple e-commerce API — products, orders, and customers. Include pagination, DataLoader for customers, and mutation error handling.
+
+**Expected output:**
+- Schema: `Product`, `Order`, `Customer`, `OrderConnection`, `UserError` types
+- `Query.orders` with cursor pagination returning `OrderConnection`
+- `Mutation.createOrder` returning `CreateOrderPayload` with errors array
+- `Order.customer` resolver using DataLoader (not direct DB query)
+- `createLoaders()` function per request, batching customer lookups by ID
+- Auth check: only authenticated users can view their own orders
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. Building GraphQL APIs or AI-powered data layers? [uitbreiden.com](https://uitbreiden.com/)

package/skills/database/nl/graphql.md

@@ -0,0 +1,181 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../graphql.md).
+
+# GraphQL Skill
+
+## Wanneer te activeren
+- Een GraphQL-schema ontwerpen (typen, queries, mutaties, subscriptions)
+- Resolvers implementeren in Node.js (Apollo Server, Pothos, GraphQL Yoga)
+- Prisma instellen met een GraphQL API
+- GraphQL-queries en -fragments schrijven voor een frontend-client
+- Cursor-gebaseerde of offset-paginering implementeren in GraphQL
+- DataLoader instellen voor N+1-querypreventie
+- Authenticatie en autorisatie toevoegen aan een GraphQL API
+- GraphQL-prestaties of N+1-problemen debuggen
+
+## Wanneer NIET te gebruiken
+- REST API's waar GraphQL complexiteit toevoegt zonder voordeel (eenvoudige CRUD, webhooks, bestandsuploads)
+- gRPC of event-driven systemen
+- Gevallen waarbij de client altijd de volledige respons nodig heeft (veldkeuze van GraphQL voegt geen waarde toe)
+
+## Instructies
+
+### Schema-ontwerpprincipes
+```graphql
+# Typenamen: PascalCase enkelvoudige zelfstandige naamwoorden
+# Veldnamen: camelCase
+# Enums: SCREAMING_SNAKE_CASE-waarden
+
+type Order {
+  id: ID!
+  status: OrderStatus!
+  customer: Customer!       # Genest type — geef altijd het object terug, niet alleen het ID
+  items: [OrderItem!]!     # Niet-null lijst van niet-null items
+  totalAmount: Float!
+  createdAt: DateTime!
+}
+
+enum OrderStatus {
+  PENDING
+  COMPLETED
+  CANCELLED
+}
+
+# Queries: retourneer nullable voor enkelvoudig item (niet gevonden = null), niet-null voor lijsten
+type Query {
+  order(id: ID!): Order       # Nullable — null als niet gevonden
+  orders(filter: OrderFilter): [Order!]!  # Niet-null lijst
+  me: User                    # Nullable — null als niet geauthenticeerd
+}
+
+# Mutaties: geef altijd het gemuteerde object terug plus een errors-array
+type Mutation {
+  createOrder(input: CreateOrderInput!): CreateOrderPayload!
+}
+
+type CreateOrderPayload {
+  order: Order          # Null als mutatie mislukte
+  errors: [UserError!]! # Leeg als geslaagd
+}
+
+type UserError {
+  field: String
+  message: String!
+}
+```
+
+### N+1-preventie met DataLoader
+```typescript
+import DataLoader from 'dataloader';
+
+// Maak per request — nooit singleton (aanvraagdata-isolatie)
+export function createLoaders() {
+  return {
+    customerLoader: new DataLoader<string, Customer>(async (ids) => {
+      const customers = await db.customer.findMany({
+        where: { id: { in: [...ids] } }
+      });
+      // Moet in dezelfde volgorde worden geretourneerd als ids
+      const customerMap = new Map(customers.map(c => [c.id, c]));
+      return ids.map(id => customerMap.get(id) ?? new Error(`Customer ${id} not found`));
+    }),
+  };
+}
+
+// Resolver — gebruikt loader, geen directe DB-aanroep
+const resolvers = {
+  Order: {
+    customer: (order, _, { loaders }) => loaders.customerLoader.load(order.customerId),
+  }
+};
+```
+
+### Cursor-gebaseerde paginering (voorkeur boven offset)
+```graphql
+type OrderConnection {
+  edges: [OrderEdge!]!
+  pageInfo: PageInfo!
+  totalCount: Int!
+}
+
+type OrderEdge {
+  node: Order!
+  cursor: String!
+}
+
+type PageInfo {
+  hasNextPage: Boolean!
+  hasPreviousPage: Boolean!
+  startCursor: String
+  endCursor: String
+}
+
+type Query {
+  orders(first: Int, after: String, last: Int, before: String): OrderConnection!
+}
+```
+
+### Autorisatiepatroon
+```typescript
+// Veldniveau-autorisatie in resolver
+const resolvers = {
+  Query: {
+    adminStats: (_, __, { user }) => {
+      if (!user || user.role !== 'ADMIN') {
+        throw new GraphQLError('Unauthorized', {
+          extensions: { code: 'UNAUTHORIZED' }
+        });
+      }
+      return getAdminStats();
+    }
+  },
+  Order: {
+    // Objectniveau: geef gevoelige velden alleen terug aan de eigenaar van de bestelling
+    internalNotes: (order, _, { user }) => {
+      if (user?.id !== order.customerId && user?.role !== 'ADMIN') return null;
+      return order.internalNotes;
+    }
+  }
+};
+```
+
+### Prisma + GraphQL-patroon
+```typescript
+// Resolver met Prisma — vermijd over-fetching
+const resolvers = {
+  Query: {
+    order: async (_, { id }, { prisma, user }) => {
+      const order = await prisma.order.findUnique({
+        where: { id },
+        select: {
+          id: true,
+          status: true,
+          customerId: true,
+          totalAmount: true,
+          createdAt: true,
+          // Selecteer hier GEEN items — laat de items-resolver dit afhandelen
+          // met DataLoader om N+1 te vermijden
+        }
+      });
+      if (!order) return null;
+      if (order.customerId !== user?.id) throw new GraphQLError('Forbidden');
+      return order;
+    }
+  }
+};
+```
+
+## Voorbeeld
+
+**Gebruiker:** Ontwerp een GraphQL-schema en resolvers voor een eenvoudige e-commerce API — producten, bestellingen en klanten. Inclusief paginering, DataLoader voor klanten en afhandeling van mutatiefouten.
+
+**Verwachte output:**
+- Schema: typen `Product`, `Order`, `Customer`, `OrderConnection`, `UserError`
+- `Query.orders` met cursor-paginering die `OrderConnection` retourneert
+- `Mutation.createOrder` die `CreateOrderPayload` retourneert met errors-array
+- `Order.customer`-resolver met DataLoader (geen directe DB-query)
+- `createLoaders()`-functie per aanvraag, klant-lookups batchen op ID
+- Auth-controle: alleen geauthenticeerde gebruikers kunnen hun eigen bestellingen bekijken
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. GraphQL API's of AI-aangedreven datalaag bouwen? [uitbreiden.com](https://uitbreiden.com/)

package/skills/devops-infra/de/docker.md

@@ -0,0 +1,133 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../docker.md).
+
+# Docker Skill
+
+## Wann aktivieren
+- Dockerfiles für die Produktion schreiben oder optimieren
+- Multi-Stage-Builds zur Reduzierung der Image-Größe einrichten
+- Docker Compose-Dateien für die lokale Entwicklung schreiben
+- Container-Startfehler oder Layer-Cache-Probleme debuggen
+- Nicht-Root-Benutzer, Health-Checks und Image-Sicherheit konfigurieren
+- .dockerignore für effiziente Builds einrichten
+- Build-Skripte oder CI/CD Docker-Build-Pipelines schreiben
+
+## Wann NICHT verwenden
+- Kubernetes-Manifeste (Kubernetes Skill verwenden)
+- Buildpacks (Heroku, Cloud Native Buildpacks) — anderes Build-System
+- Virtuelle Maschinen bereitstellen (andere Abstraktionsebene)
+- Nix-basierte reproduzierbare Builds
+
+## Anweisungen
+
+### Produktions-Dockerfile-Struktur
+Für kompilierte Sprachen und Node.js immer Multi-Stage-Builds verwenden:
+
+```dockerfile
+# Stage 1: Build
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+
+# Stage 2: Runtime — minimales Image
+FROM node:20-alpine AS runtime
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+WORKDIR /app
+COPY --from=builder /app/node_modules ./node_modules
+COPY . .
+USER appuser
+EXPOSE 8080
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+  CMD wget -qO- http://localhost:8080/healthz || exit 1
+CMD ["node", "server.js"]
+```
+
+### Sicherheitsregeln
+- Niemals als Root in der Produktion ausführen — immer einen Nicht-Root-Benutzer erstellen und zu diesem wechseln
+- Niemals `latest`-Tag verwenden — auf eine spezifische Version oder einen Digest pinnen
+- Alpine oder distroless-Basis-Images gegenüber vollem Debian/Ubuntu bevorzugen
+- Niemals `.env`-Dateien in das Image kopieren — Secrets als Laufzeit-Umgebungsvariablen übergeben
+- Images mit `docker scout` oder Trivy scannen, bevor sie in die Produktion gepusht werden
+
+### Layer-Cache-Optimierung
+Dockerfile-Anweisungen von am wenigsten bis am häufigsten geändert ordnen:
+1. Basis-Image (ändert sich selten)
+2. System-Abhängigkeiten (`apt-get`, `apk add`)
+3. Paketmanager-Dateien (`package.json`, `requirements.txt`)
+4. Paket-Installation (`npm ci`, `pip install`)
+5. Anwendungscode (`COPY . .`) — ändert sich am häufigsten, muss zuletzt stehen
+
+### .dockerignore — immer einschließen
+```
+node_modules/
+.git/
+.env
+.env.*
+*.md
+Dockerfile*
+docker-compose*
+.dockerignore
+coverage/
+.nyc_output/
+__pycache__/
+*.pyc
+.pytest_cache/
+```
+
+### Docker Compose für die lokale Entwicklung
+```yaml
+services:
+  app:
+    build:
+      context: .
+      target: builder          # Build-Stage verwenden, nicht Runtime-Stage lokal
+    volumes:
+      - .:/app                 # Hot Reload
+      - /app/node_modules      # Container node_modules nicht überschreiben
+    ports:
+      - "8080:8080"
+    environment:
+      - NODE_ENV=development
+    depends_on:
+      db:
+        condition: service_healthy
+
+  db:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: app
+      POSTGRES_PASSWORD: dev_password   # Nur Dev — niemals Produktion
+      POSTGRES_DB: appdb
+    ports:
+      - "5432:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U app -d appdb"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+volumes:
+  postgres_data:
+```
+
+### Häufige Build-Fehler
+- `COPY` schlägt lautlos fehl, wenn die Quelle nicht existiert — prüfen, ob `.dockerignore` benötigte Dateien ausschließt
+- Layer-Cache unerwartet invalidiert — prüfen, ob ein `COPY` vor den Install-Schritten geänderte Dateien einbezieht
+- Zugriff verweigert zur Laufzeit — Dateibesitz beim Verwenden von `COPY --from` mit einem Nicht-Root-Benutzer prüfen
+
+## Beispiel
+
+**Benutzer:** Ein Produktions-Dockerfile für eine Python FastAPI-App mit Multi-Stage-Build, Nicht-Root-Benutzer und Health-Check schreiben.
+
+**Erwartete Ausgabe:**
+- Stage 1 (builder): `python:3.12-slim`, Abhängigkeiten mit `pip install --no-cache-dir` installieren
+- Stage 2 (runtime): `python:3.12-slim`, Nicht-Root-Benutzer, nur Wheels/Deps vom Builder + App-Code kopieren
+- `HEALTHCHECK` trifft `/healthz`-Endpunkt
+- `CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]`
+- `.dockerignore` deckt `__pycache__`, `.env`, `.git`, `*.pyc` ab
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. KI-Workloads containerisieren oder cloud-native Systeme bauen? [uitbreiden.com](https://uitbreiden.com/)

package/skills/devops-infra/de/github-actions.md

@@ -0,0 +1,179 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../github-actions.md).
+
+# GitHub Actions Skill
+
+## Wann aktivieren
+- CI/CD-Pipelines für Tests, Linting, Build und Deployment schreiben
+- Matrix-Builds über mehrere Betriebssysteme oder Sprachversionen einrichten
+- Umgebungsschutzregeln und Deployment-Gates konfigurieren
+- Wiederverwendbare Workflows oder zusammengesetzte Actions schreiben
+- Docker-Build und Push zu einer Container-Registry einrichten
+- OIDC-Authentifizierung bei Cloud-Providern konfigurieren (keine langlebigen Secrets)
+- Fehlschlagende Workflows debuggen oder Workflow-Syntaxfehler verstehen
+- Caching für Abhängigkeiten einrichten (npm, pip, Go-Module)
+
+## Wann NICHT verwenden
+- GitLab CI, CircleCI, Jenkins — andere Pipeline-Systeme
+- Lokale Entwicklungsautomatisierung (Makefile oder Skripte verwenden)
+- Cron-Jobs, die nicht an ein Repository gebunden sind (Cloud-Scheduler verwenden)
+
+## Anweisungen
+
+### Workflow-Dateistruktur
+```yaml
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+# Explizite Berechtigungen — niemals Standard write-all verwenden
+permissions:
+  contents: read
+  pull-requests: write    # Nur wenn benötigt (z.B. Kommentare posten)
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test
+```
+
+### Berechtigungen — immer explizit
+Niemals `permissions: write-all` als Standard verwenden. Immer Mindestberechtigungen deklarieren:
+```yaml
+permissions:
+  contents: read          # Repository lesen
+  packages: write         # In GitHub Container Registry pushen
+  id-token: write         # OIDC für Cloud-Auth
+  pull-requests: write    # Kommentare zu PRs
+```
+
+### Secrets — OIDC über langlebige Anmeldedaten
+OIDC (OpenID Connect) für Cloud-Authentifizierung verwenden — keine gespeicherten Secrets:
+
+```yaml
+# AWS OIDC — kein AWS_ACCESS_KEY_ID erforderlich
+- name: Configure AWS credentials
+  uses: aws-actions/configure-aws-credentials@v4
+  with:
+    role-to-assume: arn:aws:iam::123456789:role/github-actions-role
+    aws-region: eu-west-1
+
+# GCP OIDC
+- name: Authenticate to GCP
+  uses: google-github-actions/auth@v2
+  with:
+    workload_identity_provider: projects/123/locations/global/workloadIdentityPools/pool/providers/github
+    service_account: deploy@project.iam.gserviceaccount.com
+```
+
+### Abhängigkeits-Caching
+Abhängigkeiten immer cachen, um die Build-Zeit zu verkürzen:
+```yaml
+# Node.js
+- uses: actions/setup-node@v4
+  with:
+    node-version: '20'
+    cache: 'npm'          # Eingebautes Caching — kein manueller Cache-Schritt erforderlich
+
+# Python
+- uses: actions/setup-python@v5
+  with:
+    python-version: '3.12'
+    cache: 'pip'
+
+# Go
+- uses: actions/setup-go@v5
+  with:
+    go-version: '1.22'
+    cache: true
+```
+
+### Umgebungs-Gates für Produktions-Deployments
+```yaml
+jobs:
+  deploy-production:
+    environment: production    # Referenziert GitHub Environment mit Schutzregeln
+    needs: [test, build]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Deploy
+        run: ./scripts/deploy.sh
+```
+
+Umgebungsschutzregeln in den GitHub-Einstellungen einrichten:
+- Erforderliche Reviewer für Produktions-Deployments
+- Wartezeit zwischen Staging und Produktion
+- Auf spezifische Branches beschränken (nur `main`)
+
+### Matrix-Builds
+```yaml
+jobs:
+  test:
+    strategy:
+      matrix:
+        node-version: [18, 20, 22]
+        os: [ubuntu-latest, windows-latest]
+      fail-fast: false    # Nicht alle bei erstem Fehler abbrechen
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+```
+
+### Wiederverwendbare Workflows
+```yaml
+# .github/workflows/deploy.yml — wiederverwendbar
+on:
+  workflow_call:
+    inputs:
+      environment:
+        required: true
+        type: string
+    secrets:
+      deploy-token:
+        required: true
+
+# Aufrufer
+jobs:
+  deploy:
+    uses: ./.github/workflows/deploy.yml
+    with:
+      environment: production
+    secrets:
+      deploy-token: ${{ secrets.DEPLOY_TOKEN }}
+```
+
+### Häufige Fehler
+- `actions/checkout@v4` fehlt — immer als erster Schritt
+- Secrets nicht zugänglich in Forks — `pull_request_target` vorsichtig verwenden (Sicherheitsrisiko)
+- Cache nicht getroffen — Schlüssel muss exakt übereinstimmen; `restore-keys` als Fallback verwenden
+- OIDC schlägt fehl — Trust Policy beim Cloud-Provider prüfen, ob das Repository und der Branch erlaubt sind
+
+## Beispiel
+
+**Benutzer:** Eine CI/CD-Pipeline für eine Node.js-App schreiben: Tests bei PRs ausführen, Docker-Image beim Merge zu main bauen und pushen, mit einem manuellen Genehmigungsgate in der Produktion deployen.
+
+**Erwartete Ausgabe:**
+- `on: push/pull_request`-Trigger
+- `test`-Job: checkout, setup-node mit Cache, `npm ci`, `npm test`
+- `build`-Job (beim Push zu main, benötigt test): Docker-Build + Push zu GHCR mit OIDC
+- `deploy`-Job: `environment: production` (erfordert Genehmigung), ruft Deploy-Skript auf
+- Expliziter `permissions:`-Block — Mindestanforderungen
+- Keine hartcodierten Secrets — OIDC für Registry-Auth
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. CI/CD für KI-Produkte oder Cloud-Deployments aufbauen? [uitbreiden.com](https://uitbreiden.com/)