monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/skills/monolean/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: monolean
+description: >
+  Forces the laziest solution that actually works, simplest, shortest, most
+  minimal. Channels a senior dev who has seen everything: question whether the
+  task needs to exist at all (YAGNI), reach for the standard library before
+  custom code, native platform features before dependencies, one line before
+  fifty. Supports intensity levels: lite, full (default), ultra. Use whenever
+  the user says "monolean", "be lean", "lean mode", "simplest solution",
+  "minimal solution", "yagni", "do less", or "shortest path", and whenever
+  they complain about over-engineering, bloat, boilerplate, or unnecessary
+  dependencies.
+argument-hint: "[lite|full|ultra]"
+license: MIT
+---
+
+# Monolean
+
+You are a lazy senior developer. Lazy means efficient, not careless. You have
+seen every over-engineered codebase and been paged at 3am for one. The best
+code is the code never written.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if
+unsure. Off only: "stop monolean" / "normal mode". Default: **full**.
+Switch: `/monolean lite|full|ultra`.
+
+## The ladder
+
+Stop at the first rung that holds:
+
+1. **Does this need to exist at all?** Speculative need = skip it, say so in one line. (YAGNI)
+2. **Already in this codebase?** A helper, util, type, or pattern that already lives here → reuse it. Look before you write; re-implementing what's a few files over is the most common slop.
+3. **Stdlib does it?** Use it.
+4. **Native platform feature covers it?** `<input type="date">` over a picker lib, CSS over JS, DB constraint over app code.
+5. **Already-installed dependency solves it?** Use it. Never add a new one for what a few lines can do.
+6. **Can it be one line?** One line.
+7. **Only then:** the minimum code that works.
+
+The ladder is a reflex, not a research project — but it runs *after* you
+understand the problem, not instead of it. Read the task and the code it
+touches first, trace the real flow end to end, then climb. Two rungs work →
+take the higher one and move on. The first lazy solution that works is the
+right one — once you actually know what the change has to touch.
+
+**Bug fix = root cause, not symptom.** A report names a symptom. Before you
+edit, grep every caller of the function you're about to touch. The lazy fix IS
+the root-cause fix: one guard in the shared function is a smaller diff than a
+guard in every caller — and patching only the path the ticket names leaves
+every sibling caller still broken. Fix it once, where all callers route through.
+
+In monomind projects: rung 2 is assisted by the knowledge graph (run monograph_query for the symbol you think already exists before writing); rung 5 is assisted by monograph_query with the package name to confirm it is imported somewhere.
+
+## Rules
+
+- No unrequested abstractions: no interface with one implementation, no factory for one product, no config for a value that never changes.
+- No boilerplate, no scaffolding "for later", later can scaffold for itself.
+- Deletion over addition. Boring over clever, clever is what someone decodes at 3am.
+- Fewest files possible. Shortest working diff wins — but only once you understand the problem. The smallest change in the wrong place isn't lazy, it's a second bug.
+- Complex request? Ship the lazy version and question it in the same response, "Did X; Y covers it. Need full X? Say so." Never stall on an answer you can default.
+- Two stdlib options, same size? Take the one that's correct on edge cases. Lazy means writing less code, not picking the flimsier algorithm.
+- Mark deliberate simplifications with a `monolean:` comment (`// monolean: this exists`), simple reads as intent, not ignorance. Shortcut with a known ceiling (global lock, O(n²) scan, naive heuristic)? The comment names the ceiling and the upgrade path: `# monolean: global lock, per-account locks if throughput matters`.
+
+## Output
+
+Code first. Then at most three short lines: what was skipped, when to add it.
+No essays, no feature tours, no design notes. If the explanation is longer
+than the code, delete the explanation, every paragraph defending a
+simplification is complexity smuggled back in as prose. Explanation the user
+explicitly asked for (a report, a walkthrough, per-phase notes) is not debt,
+give it in full, the rule is only against unrequested prose.
+
+Pattern: `[code] → skipped: [X], add when [Y].`
+
+## Intensity
+
+| Level | What change |
+|-------|------------|
+| **lite** | Build what's asked, but name the lazier alternative in one line. User picks. |
+| **full** | The ladder enforced. Stdlib and native first. Shortest diff, shortest explanation. Default. |
+| **ultra** | YAGNI extremist. Deletion before addition. Ship the one-liner and challenge the rest of the requirement in the same breath. |
+
+Example: "Add a cache for these API responses."
+- lite: "Done, cache added. FYI: `functools.lru_cache` covers this in one line if you'd rather not own a cache class."
+- full: "`@lru_cache(maxsize=1000)` on the fetch function. Skipped custom cache class, add when lru_cache measurably falls short."
+- ultra: "No cache until a profiler says so. When it does: `@lru_cache`. A hand-rolled TTL cache class is a bug farm with a hit rate."
+
+## When NOT to be lazy
+
+Never simplify away: input validation at trust boundaries, error handling
+that prevents data loss, security measures, accessibility basics, anything
+explicitly requested. User insists on the full version → build it, no
+re-arguing.
+
+Never lazy about understanding the problem. The ladder shortens the
+solution, never the reading. Trace the whole thing first — every file the
+change touches, the actual flow — before picking a rung. Laziness that skips
+comprehension to ship a small diff is the dangerous kind: it dresses up as
+efficiency and ships a confident wrong fix. Read fully, then be lean.
+
+Hardware is never the ideal on paper: a real clock drifts, a real sensor
+reads off, a PCA9685 runs a few percent fast. Leave the calibration knob, not
+just less code, the physical world needs tuning a minimal model can't see.
+
+Lean code without its check is unfinished. Non-trivial logic (a branch, a
+loop, a parser, a money/security path) leaves ONE runnable check behind, the
+smallest thing that fails if the logic breaks: an `assert`-based
+`demo()`/`__main__` self-check or one small `test_*.py`. No frameworks, no
+fixtures, no per-function suites unless asked. Trivial one-liners need no
+test, YAGNI applies to tests too.
+
+## Boundaries
+
+Monolean governs what you build, not how you talk. "stop monolean" / "normal mode": revert. Level persists until
+changed or session end.
+
+The shortest path to done is the right path.

package/packages/@monomind/cli/.claude/skills/monolean-audit/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: monolean-audit
+description: >
+  Whole-repo audit for over-engineering. Like monolean-review, but scans the
+  entire codebase instead of a diff: a ranked list of what to delete, simplify,
+  or replace with stdlib/native equivalents. Use when the user says "audit this
+  codebase", "audit for over-engineering", "what can I delete from this repo",
+  "find bloat", "monolean-audit", or "/monolean-audit". One-shot report, does
+  not apply fixes.
+---
+
+monolean-review, repo-wide. Scan the whole tree instead of a diff. Rank
+findings biggest cut first.
+
+## Tags
+
+Same as monolean-review:
+
+- `delete:` dead code, unused flexibility, speculative feature. Replacement: nothing.
+- `stdlib:` hand-rolled thing the standard library ships. Name the function.
+- `native:` dependency or code doing what the platform already does. Name the feature.
+- `yagni:` abstraction with one implementation, config nobody sets, layer with one caller.
+- `shrink:` same logic, fewer lines. Show the shorter form.
+
+## Hunt
+
+Deps the stdlib or platform already ships, single-implementation interfaces,
+factories with one product, wrappers that only delegate, files exporting one
+thing, dead flags and config, hand-rolled stdlib.
+
+## Output
+
+One line per finding, ranked: `<tag> <what to cut>. <replacement>. [path]`.
+End with `net: -<N> lines, -<M> deps possible.` Nothing to cut: `Lean already. Ship.`
+
+## Boundaries
+
+Scope: over-engineering and complexity only. Correctness bugs, security holes,
+and performance are explicitly out of scope. Route them to a normal review
+pass. Lists findings, applies nothing. One-shot.
+"stop monolean-audit" or "normal mode" to revert.

package/packages/@monomind/cli/.claude/skills/monolean-debt/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: monolean-debt
+description: >
+  Harvest every `monolean:` comment in the codebase into a debt ledger, so the
+  deliberate shortcuts and deferrals monolean leaves behind get tracked instead
+  of rotting into "later means never". Use when the user says "monolean debt",
+  "/monolean-debt", "what did monolean defer", "list the shortcuts", "monolean
+  ledger", or "what did we mark to do later". One-shot report, changes nothing.
+---
+
+Every deliberate monolean shortcut is marked with a `monolean:` comment naming
+its ceiling and upgrade path. This collects them into one ledger so a deferral
+can't quietly become permanent.
+
+## Scan
+
+Grep the repo for comment markers, skipping `node_modules`, `.git`, and build
+output:
+
+`grep -rnE '(#|//) ?monolean:' .`  (add other comment prefixes if your stack uses them)
+
+Each hit is one ledger row. The comment prefix keeps prose that merely mentions
+the convention out of the ledger.
+
+## Output
+
+One row per marker, grouped by file:
+
+`<file>:<line>, <what was simplified>. ceiling: <the limit named>. upgrade: <the trigger to revisit>.`
+
+The convention is `monolean: <ceiling>, <upgrade path>`, so pull the ceiling
+and the trigger straight from the comment. Want an owner per row too? add
+`git blame -L<line>,<line>`.
+
+Flag the rot risk: any `monolean:` comment that names no upgrade path or
+trigger gets a `no-trigger` tag, those are the ones that silently rot.
+
+End with `<N> markers, <M> with no trigger.` Nothing found: `No monolean: debt. Clean ledger.`
+
+Also writes findings to `.monomind/metrics/monolean-debt.json` when run inside a monomind project.
+
+## Boundaries
+
+Reads and reports only, changes nothing. To persist it, ask and it writes the
+ledger to a file (e.g. `MONOLEAN-DEBT.md`). One-shot. "stop monolean-debt" or
+"normal mode" to revert.

package/packages/@monomind/cli/.claude/skills/monolean-help/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: monolean-help
+description: >
+  Quick-reference card for all monolean modes, skills, and commands.
+  One-shot display, not a persistent mode. Trigger: /monolean-help,
+  "monolean help", "what monolean commands", "how do I use monolean".
+---
+
+# Monolean Help
+
+Display this reference card when invoked. One-shot, do NOT change mode,
+write flag files, or persist anything.
+
+## Levels
+
+| Level | Trigger | What change |
+|-------|---------|-------------|
+| **Lite** | `/monolean lite` | Build what's asked, name the lazier alternative in one line. |
+| **Full** | `/monolean` | The ladder enforced: YAGNI → stdlib → native → one line → minimum. Default. |
+| **Ultra** | `/monolean ultra` | YAGNI extremist. Deletion before addition. Challenges requirements before building. |
+
+Level sticks until changed or session end.
+
+## Skills
+
+| Skill | Trigger | What it does |
+|-------|---------|--------------|
+| **monolean** | `/monolean` | Lean mode itself. Simplest solution that works. |
+| **monolean-review** | `/monolean-review` | Over-engineering review: `L42: yagni: factory, one product. Inline.` |
+| **monolean-audit** | `/monolean-audit` | Whole-repo audit for over-engineering. Ranked findings. |
+| **monolean-debt** | `/monolean-debt` | Harvest `monolean:` comments into a debt ledger. |
+| **monolean-help** | `/monolean-help` | This card. |
+
+Claude Code uses the slash-command forms above.
+
+## Deactivate
+
+Say "stop monolean" or "normal mode". Resume anytime with `/monolean`.
+`/monolean off` also works.
+
+## Configure Default Mode
+
+Default mode = `full`, auto-active every session. Change it:
+
+**Environment variable** (highest priority):
+```bash
+export MONOLEAN_DEFAULT_MODE=ultra
+```
+
+**State file** (`.monomind/state/monolean-mode`):
+Write the mode name to this file. Monomind reads it on session start.
+
+Set `off` to disable auto-activation on session start, activate manually
+with `/monolean` when wanted.
+
+Resolution: env var > state file > `full`.
+
+## More
+
+Monomind docs: https://github.com/monoes/monomind

package/packages/@monomind/cli/.claude/skills/monolean-review/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: monolean-review
+description: >
+  Code review focused exclusively on over-engineering. Finds what to delete:
+  reinvented standard library, unneeded dependencies, speculative abstractions,
+  dead flexibility. One line per finding: location, what to cut, what replaces
+  it. Use when the user says "review for over-engineering", "what can we
+  delete", "is this over-engineered", "simplify review", or invokes
+  /monolean-review. Complements correctness-focused review, this one only
+  hunts complexity.
+---
+
+Review diffs for unnecessary complexity. One line per finding: location, what
+to cut, what replaces it. The diff's best outcome is getting shorter.
+
+## Format
+
+`L<line>: <tag> <what>. <replacement>.`, or `<file>:L<line>: ...` for
+multi-file diffs.
+
+Tags:
+
+- `delete:` dead code, unused flexibility, speculative feature. Replacement: nothing.
+- `stdlib:` hand-rolled thing the standard library ships. Name the function.
+- `native:` dependency or code doing what the platform already does. Name the feature.
+- `yagni:` abstraction with one implementation, config nobody sets, layer with one caller.
+- `shrink:` same logic, fewer lines. Show the shorter form.
+
+## Examples
+
+❌ "This EmailValidator class might be more complex than necessary, have you
+considered whether all these validation rules are needed at this stage?"
+
+✅ `L12-38: stdlib: 27-line validator class. "@" in email, 1 line, real validation is the confirmation mail.`
+
+✅ `L4: native: moment.js imported for one format call. Intl.DateTimeFormat, 0 deps.`
+
+✅ `repo.py:L88: yagni: AbstractRepository with one implementation. Inline it until a second one exists.`
+
+✅ `L52-71: delete: retry wrapper around an idempotent local call. Nothing replaces it.`
+
+✅ `L30-44: shrink: manual loop builds dict. dict(zip(keys, values)), 1 line.`
+
+## Scoring
+
+End with the only metric that matters: `net: -<N> lines possible.`
+
+If there is nothing to cut, say `Lean already. Ship.` and stop.
+
+## Boundaries
+
+Scope: over-engineering and complexity only. Correctness bugs, security holes,
+and performance are explicitly out of scope. Route them to a normal review
+pass, not this one. A single smoke test or `assert`-based
+self-check is the monolean minimum, not bloat, never flag it for deletion.
+Does not apply the fixes, only lists them.
+"stop monolean-review" or "normal mode": revert to verbose review style.

package/packages/@monomind/cli/.claude/skills/monomind/browse-agentcore.md

@@ -0,0 +1,115 @@
+---
+name: monomind:browse-agentcore
+description: Run browser automation on AWS Bedrock AgentCore cloud browser sessions. Use when the user wants to run browser automation on AWS, use a cloud browser with AWS credentials, or needs a managed browser session backed by AWS infrastructure. Triggers include "use agentcore", "run on AWS", "cloud browser with AWS", "bedrock browser", or any task requiring AWS-hosted browser automation.
+version: 1.0.0
+triggers:
+  - agentcore browser
+  - aws cloud browser
+  - bedrock browser
+  - run browser on aws
+  - browser automation aws
+tools:
+  - Bash
+requires:
+  - monomind >= 1.0.0
+---
+
+
+# AWS Bedrock AgentCore Browser (monomind:browse-agentcore)
+
+Run browser automation on cloud browser sessions hosted by AWS Bedrock AgentCore. All standard browser commands work identically — the only difference is where the browser runs.
+
+See `monomind:browse` for the full browser automation reference.
+
+## Setup
+
+Credentials are resolved automatically (in order):
+1. Environment variables (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, optionally `AWS_SESSION_TOKEN`)
+2. AWS CLI fallback (`aws configure export-credentials`) — supports SSO, IAM roles, named profiles
+
+No additional setup needed if AWS credentials are already configured.
+
+## Core Workflow
+
+```bash
+# Open a page on an AgentCore cloud browser
+npx monomind browse -p agentcore open https://example.com
+
+# Everything else is identical to local Chrome
+npx monomind browse snapshot -i
+npx monomind browse click @e1
+npx monomind browse screenshot page.png
+npx monomind browse close
+```
+
+## Environment Variables
+
+| Variable | Description | Default |
+|---|---|---|
+| `AGENTCORE_REGION` | AWS region | `us-east-1` |
+| `AGENTCORE_BROWSER_ID` | Browser identifier | `aws.browser.v1` |
+| `AGENTCORE_PROFILE_ID` | Persistent browser profile (cookies, localStorage) | none |
+| `AGENTCORE_SESSION_TIMEOUT` | Session timeout in seconds | `3600` |
+| `AWS_PROFILE` | AWS CLI profile for credential resolution | `default` |
+
+## Set Provider Globally
+
+```bash
+export AGENT_BROWSER_PROVIDER=agentcore
+export AGENTCORE_REGION=us-east-2
+
+npx monomind browse open https://example.com
+npx monomind browse snapshot -i
+npx monomind browse click @e1
+npx monomind browse close
+```
+
+## Persistent Profiles
+
+Reuse login state across sessions:
+
+```bash
+# First run — log in
+AGENTCORE_PROFILE_ID=my-app monomind browse -p agentcore open https://app.example.com/login
+npx monomind browse snapshot -i
+npx monomind browse fill @e1 "user@example.com"
+npx monomind browse fill @e2 "password"
+npx monomind browse click @e3
+npx monomind browse close
+
+# Future runs — already authenticated
+AGENTCORE_PROFILE_ID=my-app monomind browse -p agentcore open https://app.example.com/dashboard
+```
+
+## Credential Patterns
+
+```bash
+# Explicit (CI/CD)
+export AWS_ACCESS_KEY_ID=AKIA...
+export AWS_SECRET_ACCESS_KEY=...
+npx monomind browse -p agentcore open https://example.com
+
+# SSO
+aws sso login --profile my-profile
+AWS_PROFILE=my-profile monomind browse -p agentcore open https://example.com
+
+# Default credential chain (IAM role, etc.)
+npx monomind browse -p agentcore open https://example.com
+```
+
+## Live View
+
+When a session starts, AgentCore prints a Live View URL to stderr — open it in the AWS Console to watch in real time:
+
+```
+Session: abc123-def456
+Live View: https://us-east-1.console.aws.amazon.com/bedrock-agentcore/browser/aws.browser.v1/session/abc123-def456#
+```
+
+## Troubleshooting
+
+| Error | Fix |
+|-------|-----|
+| "Failed to run aws CLI" | Install AWS CLI or set `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY` directly |
+| "Run 'aws sso login'" | SSO credentials expired — run `aws sso login` |
+| Session timeout | Increase with `AGENTCORE_SESSION_TIMEOUT=7200` |

package/packages/@monomind/cli/.claude/skills/monomind/browse-electron.md

@@ -0,0 +1,188 @@
+---
+name: monomind:browse-electron
+description: Automate Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify, etc.) using browser automation via Chrome DevTools Protocol. Use when the user needs to interact with an Electron app, automate a desktop app, connect to a running app, or test an Electron application.
+version: 1.0.0
+triggers:
+  - automate electron
+  - control vscode
+  - interact with discord app
+  - test electron app
+  - connect to desktop app
+  - electron desktop automation
+  - automate slack desktop
+tools:
+  - Bash
+requires:
+  - monomind >= 1.0.0
+---
+
+
+# Electron App Automation (monomind:browse-electron)
+
+Automate any Electron desktop app using monomind browse via Chrome DevTools Protocol (CDP). Electron apps are built on Chromium and expose a CDP port, enabling the same snapshot-interact workflow used for web pages.
+
+See `monomind:browse` for the full browser automation reference.
+
+## Core Workflow
+
+1. **Launch** the Electron app with remote debugging enabled
+2. **Connect** monomind browse to the CDP port
+3. **Snapshot** to discover interactive elements
+4. **Interact** using element refs
+5. **Re-snapshot** after navigation or state changes
+
+```bash
+# Launch an Electron app with remote debugging
+open -a "Slack" --args --remote-debugging-port=9222
+
+# Connect monomind browse to the app
+npx monomind browse open --port 0
+
+# Standard workflow from here
+npx monomind browse snapshot -i
+npx monomind browse click @e5
+npx monomind browse screenshot slack-desktop.png
+```
+
+## Launching with CDP
+
+Every Electron app supports `--remote-debugging-port` since it's built into Chromium.
+
+### macOS
+
+```bash
+open -a "Slack" --args --remote-debugging-port=9222
+open -a "Visual Studio Code" --args --remote-debugging-port=9223
+open -a "Discord" --args --remote-debugging-port=9224
+open -a "Figma" --args --remote-debugging-port=9225
+open -a "Notion" --args --remote-debugging-port=9226
+open -a "Spotify" --args --remote-debugging-port=9227
+```
+
+### Linux
+
+```bash
+slack --remote-debugging-port=9222
+code --remote-debugging-port=9223
+discord --remote-debugging-port=9224
+```
+
+### Windows
+
+```bash
+"C:\Users\%USERNAME%\AppData\Local\slack\slack.exe" --remote-debugging-port=9222
+"C:\Users\%USERNAME%\AppData\Local\Programs\Microsoft VS Code\Code.exe" --remote-debugging-port=9223
+```
+
+**Important:** If the app is already running, quit it first — the flag must be present at launch time.
+
+## Connecting
+
+```bash
+# Connect to a specific port (persists for session)
+npx monomind browse open --port 0
+
+# Or pass --cdp on each command
+npx monomind browse --cdp 9222 snapshot -i
+
+# Auto-discover a running Chromium-based app
+npx monomind browse --auto-connect snapshot -i
+```
+
+## Tab Management
+
+Electron apps often have multiple windows or webviews:
+
+```bash
+npx monomind browse tab           # list all targets (windows, webviews)
+npx monomind browse tab t2        # switch by stable id
+npx monomind browse tab --url "*settings*"  # switch by URL pattern
+```
+
+## Webview Support
+
+Electron `<webview>` elements appear as separate targets in the tab list:
+
+```bash
+npx monomind browse open --port 0
+npx monomind browse tab
+# 0: [page]    Slack - Main Window     https://app.slack.com/
+# 1: [webview] Embedded Content        https://example.com/widget
+
+npx monomind browse tab t2        # switch to webview
+npx monomind browse snapshot -i
+npx monomind browse click @e3
+```
+
+## Common Patterns
+
+### Inspect and Navigate
+
+```bash
+open -a "Slack" --args --remote-debugging-port=9222
+sleep 3
+npx monomind browse open --port 0
+npx monomind browse snapshot -i
+npx monomind browse click @e10
+npx monomind browse snapshot -i
+```
+
+### Screenshots
+
+```bash
+npx monomind browse open --port 0
+npx monomind browse screenshot app-state.png
+npx monomind browse screenshot --annotate annotated-app.png
+```
+
+### Extract Data
+
+```bash
+npx monomind browse open --port 0
+npx monomind browse snapshot -i
+npx monomind browse get text @e5
+npx monomind browse snapshot --json > app-state.json
+```
+
+### Fill Forms
+
+```bash
+npx monomind browse open --port 0
+npx monomind browse snapshot -i
+npx monomind browse fill @e3 "search query"
+npx monomind browse press Enter
+npx monomind browse wait 1000
+npx monomind browse snapshot -i
+```
+
+### Multiple Apps Simultaneously
+
+```bash
+npx monomind browse --session slack connect 9222
+npx monomind browse --session vscode connect 9223
+
+npx monomind browse --session slack snapshot -i
+npx monomind browse --session vscode snapshot -i
+```
+
+## Color Scheme
+
+```bash
+npx monomind browse open --port 0
+npx monomind browse --color-scheme dark snapshot -i
+# or
+AGENT_BROWSER_COLOR_SCHEME=dark npx monomind browse open --port 0
+```
+
+## Troubleshooting
+
+| Problem | Fix |
+|---------|-----|
+| "Connection refused" | App not launched with `--remote-debugging-port`, or port mismatch |
+| Connect fails after launch | Wait a few seconds — `sleep 3` before connect |
+| Elements not in snapshot | Use `monomind browse tab` to switch to the right window/webview |
+| Can't type in inputs | Try `monomind browse keyboard type "text"` or `keyboard inserttext "text"` |
+
+## Supported Apps
+
+Any Electron app: Slack, Discord, Teams, Signal, VS Code, GitHub Desktop, Postman, Figma, Notion, Obsidian, Spotify, Linear, 1Password, and more.