four-doctors 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ArtisansCompany
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# doctors
+
+The whole suite, one command. Runs `rails-doctor`, `design-doctor`, `qa-doctor`, and (optionally) `react-doctor`, and aggregates the scores.
+
+## Quick start
+
+```bash
+npx -y doctors@latest scan .
+```
+
+Auto-runs the doctors that apply to your project:
+
+| Doctor          | Runs when                                           |
+|-----------------|-----------------------------------------------------|
+| `rails-doctor`  | `Gemfile` + `config/routes.rb` exist                |
+| `design-doctor` | `package.json` has react / inertia / tanstack-router |
+| `qa-doctor`     | only with `--browser` (needs a running dev server)  |
+| `react-doctor`  | only with `--react-doctor`                          |
+
+## Examples
+
+```bash
+# Static-only (default) — Rails + React audit
+npx -y doctors scan .
+
+# Add browser QA against a running app
+npx -y doctors scan . --browser --url http://localhost:3000
+
+# Add the LLM vision pass
+npx -y doctors scan . --vision --url http://localhost:3000
+
+# Full sweep — every doctor, every flag
+npx -y doctors scan . --browser --vision --fill --url http://localhost:3000 --react-doctor
+
+# CI gate — fail under suite-average 80
+npx -y doctors scan . --min-score 80
+```
+
+## Output
+
+```
+doctors — suite report
+
+  ok   rails-doctor    98/100 Great  (895ms)
+  ok   design-doctor   83/100 Great  (1467ms)
+
+  Suite average: 91/100  across 2 doctors
+```
+
+`--markdown` for PR-friendly output:
+
+```
+## doctors report
+
+**Suite average: 91/100** across 2 doctors.
+
+| Doctor | Status | Score | Notes |
+|---|---|---|---|
+| `rails-doctor` | ok | 98/100 | Great |
+| `design-doctor` | ok | 83/100 | Great |
+```
+
+## Install all the skills
+
+```bash
+npx -y doctors install              # installs the meta skill
+npx -y rails-doctor install
+npx -y design-doctor install
+npx -y qa-doctor install
+```
+
+After that, your agent can call any doctor by name — and `doctors` itself when you want everything in one shot.
+
+## Source
+
+- [doctors](https://github.com/artisanscompany/doctors)
+- [rails-doctor](https://github.com/artisanscompany/rails-doctor)
+- [design-doctor](https://github.com/artisanscompany/design-doctor)
+- [qa-doctor](https://github.com/artisanscompany/qa-doctor)
+- [react-doctor](https://github.com/millionco/react-doctor) (third-party)
+
+## License
+
+MIT.

package/bin/doctors.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+"use strict";
+require("../dist/cli.js").start(process.argv.slice(2));

package/dist/cli.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.start = start;
+const detect_js_1 = require("./detect.js");
+const orchestrator_js_1 = require("./orchestrator.js");
+const tty_js_1 = require("./reporters/tty.js");
+const markdown_js_1 = require("./reporters/markdown.js");
+const installer_js_1 = require("./installer.js");
+const version_js_1 = require("./version.js");
+const USAGE = `
+Usage: doctors <command> [options]
+
+Commands:
+  scan [path]         Run every applicable doctor and aggregate the scores.
+  install             Install all four agent skills (rails-doctor, design-doctor,
+                      qa-doctor, doctors) into detected agent dirs.
+  version             Print version
+  help                Show this help
+
+Default doctors run automatically when their target is detected:
+  rails-doctor    if Gemfile + config/routes.rb exist
+  design-doctor   if package.json has react / @inertiajs/react / @tanstack/react-router
+
+Opt-in:
+  --browser           Also run qa-doctor (needs a running dev server).
+  --vision            Also run design-doctor's vision pass (needs running app).
+  --fill              Pass --fill through to qa-doctor (smart-fill forms).
+  --url URL           Forwarded to qa-doctor and design-doctor's vision pass.
+  --diff [BASE]       Forwarded to rails-doctor and design-doctor.
+  --react-doctor      Also run react-doctor (third-party).
+  --markdown          Emit combined markdown report (else TTY).
+  --no-color          Disable ANSI colours.
+
+CI gates:
+  --fail-on LEVEL     error|warning|none — fails if any doctor exits non-zero
+                      at that level. (Currently the meta uses minScore only.)
+  --min-score N       Fail if the suite average is below N.
+`;
+function start(argv) {
+    const args = argv.slice();
+    if (args.length === 0) {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const head = args[0];
+    if (head === "version" || head === "-v" || head === "--version") {
+        console.log(`doctors ${version_js_1.VERSION}`);
+        return;
+    }
+    if (head === "help" || head === "-h" || head === "--help") {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (head === "install")
+        return runInstall(args.slice(1));
+    if (head === "scan")
+        return runScan(args.slice(1));
+    return runScan(args);
+}
+function runInstall(args) {
+    const dryRun = args.includes("--dry-run");
+    const out = (0, installer_js_1.install)({ dryRun });
+    if (out.length === 0) {
+        console.log("No agent skill directories detected.");
+        return;
+    }
+    for (const r of out)
+        console.log(`${r.copied ? "✓" : " "} ${r.dest}${dryRun ? " (dry-run)" : ""}`);
+    console.log("");
+    console.log("To install the individual doctors as skills too:");
+    console.log("  npx -y rails-doctor@latest install");
+    console.log("  npx -y design-doctor@latest install");
+    console.log("  npx -y qa-doctor@latest install");
+}
+function runScan(args) {
+    const opts = parseScan(args);
+    const det = (0, detect_js_1.detect)(opts.path);
+    (async () => {
+        const runs = await (0, orchestrator_js_1.runDoctors)(det, {
+            vision: opts.vision,
+            browser: opts.browser,
+            fillForms: opts.fillForms,
+            reactDoctor: opts.reactDoctor,
+            url: opts.url,
+            diff: opts.diff,
+            failOn: opts.failOn,
+            minScore: opts.minScore,
+        });
+        if (opts.markdown)
+            process.stdout.write((0, markdown_js_1.renderMarkdown)(runs) + "\n");
+        else
+            (0, tty_js_1.renderTty)(runs, { noColor: opts.noColor });
+        const scored = runs.filter((r) => r.enabled && typeof r.score === "number");
+        if (opts.minScore !== null && scored.length > 0) {
+            const avg = Math.round(scored.reduce((s, r) => s + (r.score ?? 0), 0) / scored.length);
+            if (avg < opts.minScore)
+                process.exit(1);
+        }
+        process.exit(0);
+    })();
+}
+function parseScan(args) {
+    const opts = {
+        path: ".",
+        vision: false,
+        browser: false,
+        fillForms: false,
+        reactDoctor: false,
+        url: null,
+        diff: null,
+        markdown: false,
+        noColor: !process.stdout.isTTY,
+        failOn: "none",
+        minScore: null,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        switch (a) {
+            case "--vision":
+                opts.vision = true;
+                break;
+            case "--browser":
+                opts.browser = true;
+                break;
+            case "--fill":
+                opts.fillForms = true;
+                break;
+            case "--react-doctor":
+                opts.reactDoctor = true;
+                break;
+            case "--url":
+                opts.url = args[++i] ?? null;
+                break;
+            case "--diff": {
+                const next = args[i + 1];
+                if (next && !next.startsWith("--")) {
+                    opts.diff = next;
+                    i++;
+                }
+                else {
+                    opts.diff = "main";
+                }
+                break;
+            }
+            case "--markdown":
+                opts.markdown = true;
+                break;
+            case "--no-color":
+                opts.noColor = true;
+                break;
+            case "--fail-on": {
+                const v = args[++i];
+                if (v === "error" || v === "warning" || v === "none")
+                    opts.failOn = v;
+                break;
+            }
+            case "--min-score":
+                opts.minScore = parseInt(args[++i] ?? "0", 10);
+                break;
+            default:
+                if (!a.startsWith("--"))
+                    opts.path = a;
+        }
+    }
+    return opts;
+}

package/dist/detect.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detect = detect;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function detect(root) {
+    const rootAbs = (0, node_path_1.resolve)(root);
+    const hasRails = (0, node_fs_1.existsSync)((0, node_path_1.join)(rootAbs, "Gemfile")) && (0, node_fs_1.existsSync)((0, node_path_1.join)(rootAbs, "config", "routes.rb"));
+    const pkgPath = (0, node_path_1.join)(rootAbs, "package.json");
+    let hasFrontend = false;
+    let hasReactDoctorTarget = false;
+    if ((0, node_fs_1.existsSync)(pkgPath)) {
+        try {
+            const pkg = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf8"));
+            const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+            hasFrontend = !!(deps["react"] || deps["@inertiajs/react"] || deps["@tanstack/react-router"] || deps["next"] || deps["vue"]);
+            hasReactDoctorTarget = !!deps["react"];
+        }
+        catch { }
+    }
+    return { root: rootAbs, hasRails, hasFrontend, hasReactDoctorTarget };
+}

package/dist/installer.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.install = install;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const TARGET_DIRS = [
+    "~/.claude/skills",
+    "~/.agents/skills",
+    "~/.cursor/skills",
+    "~/.codeium/windsurf/skills",
+    "~/.config/github-copilot/skills",
+    "~/.config/opencode/skills",
+];
+function install(opts = {}) {
+    const skillSrc = (0, node_path_1.resolve)(__dirname, "..", "skills", "doctors");
+    if (!(0, node_fs_1.existsSync)(skillSrc))
+        throw new Error(`Skill source missing at ${skillSrc}`);
+    const home = process.env.HOME || "";
+    const out = [];
+    for (const target of TARGET_DIRS) {
+        const expanded = target.replace(/^~/, home);
+        const parent = (0, node_path_1.dirname)(expanded);
+        if (!(0, node_fs_1.existsSync)(parent))
+            continue;
+        const dest = (0, node_path_1.join)(expanded, "doctors");
+        if (opts.dryRun) {
+            out.push({ dest, copied: false });
+            continue;
+        }
+        (0, node_fs_1.mkdirSync)(dest, { recursive: true });
+        for (const file of (0, node_fs_1.readdirSync)(skillSrc)) {
+            (0, node_fs_1.copyFileSync)((0, node_path_1.join)(skillSrc, file), (0, node_path_1.join)(dest, file));
+        }
+        out.push({ dest, copied: true });
+    }
+    return out;
+}

package/dist/orchestrator.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctors = runDoctors;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+async function runDoctors(detected, opts) {
+    const runs = [];
+    // rails-doctor — when Rails is present
+    runs.push(await runOne({
+        name: "rails-doctor",
+        enabled: detected.hasRails,
+        reason: detected.hasRails ? "Gemfile + config/routes.rb detected" : "no Gemfile",
+        cwd: detected.root,
+        cmd: "npx",
+        args: ["-y", "rails-doctor@latest", "scan", ".", "--json", ...(opts.diff ? ["--diff", opts.diff] : [])],
+    }));
+    // design-doctor — when React frontend is present
+    runs.push(await runOne({
+        name: "design-doctor",
+        enabled: detected.hasFrontend,
+        reason: detected.hasFrontend ? "React frontend detected" : "no React frontend",
+        cwd: detected.root,
+        cmd: "npx",
+        args: ["-y", "design-doctor@latest", "scan", ".", "--json", ...(opts.diff ? ["--diff", opts.diff] : []), ...(opts.vision ? ["--vision"] : [])],
+        cacheFile: ".design-doctor/result.json",
+    }));
+    // react-doctor — opt-in (third-party, separate maintainer)
+    if (opts.reactDoctor) {
+        runs.push(await runOne({
+            name: "react-doctor",
+            enabled: detected.hasReactDoctorTarget,
+            reason: detected.hasReactDoctorTarget ? "React project + --react-doctor flag" : "no React",
+            cwd: detected.root,
+            cmd: "npx",
+            args: ["-y", "react-doctor@latest", ".", "--json"],
+        }));
+    }
+    // qa-doctor — opt-in (--browser), needs running dev server
+    if (opts.browser) {
+        runs.push(await runOne({
+            name: "qa-doctor",
+            enabled: detected.hasFrontend,
+            reason: detected.hasFrontend ? "React frontend + --browser flag" : "no React",
+            cwd: detected.root,
+            cmd: "npx",
+            args: ["-y", "qa-doctor@latest", "scan", ".", "--json", ...(opts.url ? ["--url", opts.url] : []), ...(opts.fillForms ? ["--fill"] : [])],
+            cacheFile: ".qa-doctor/result.json",
+        }));
+    }
+    return runs;
+}
+function runOne(o) {
+    return new Promise((resolveP) => {
+        if (!o.enabled) {
+            resolveP({ name: o.name, enabled: false, reason: o.reason });
+            return;
+        }
+        const t0 = Date.now();
+        const child = (0, node_child_process_1.spawn)(o.cmd, o.args, { cwd: o.cwd, stdio: ["ignore", "pipe", "pipe"] });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout.on("data", (b) => { stdoutChunks.push(b); });
+        child.stderr.on("data", (b) => { stderrChunks.push(b); });
+        child.on("close", () => {
+            const durationMs = Date.now() - t0;
+            const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+            const stderr = Buffer.concat(stderrChunks).toString("utf8");
+            const run = { name: o.name, enabled: true, reason: o.reason, durationMs };
+            // Prefer the cache file if it exists and is newer than the run start.
+            // stdout pipe buffers can truncate large JSON on macOS; the cache file
+            // is the authoritative source.
+            const cachePath = o.cacheFile ? (0, node_path_1.join)(o.cwd, o.cacheFile) : null;
+            let json = null;
+            if (cachePath && (0, node_fs_1.existsSync)(cachePath)) {
+                try {
+                    json = (0, node_fs_1.readFileSync)(cachePath, "utf8");
+                }
+                catch { }
+            }
+            if (!json)
+                json = stdout;
+            try {
+                const parsed = JSON.parse(json);
+                run.score = parsed.score ?? parsed.summary?.score;
+                run.grade = parsed.grade ?? parsed.summary?.grade;
+                run.output = json;
+            }
+            catch {
+                run.error = stderr.split("\n").find((l) => l.trim()) ?? "(unparseable JSON output)";
+            }
+            resolveP(run);
+        });
+    });
+}

package/dist/reporters/markdown.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMarkdown = renderMarkdown;
+function renderMarkdown(runs) {
+    const lines = [];
+    lines.push(`## doctors report`);
+    lines.push("");
+    const enabled = runs.filter((r) => r.enabled);
+    const scored = enabled.filter((r) => typeof r.score === "number");
+    const avg = scored.length ? Math.round(scored.reduce((s, r) => s + (r.score ?? 0), 0) / scored.length) : null;
+    if (avg !== null)
+        lines.push(`**Suite average: ${avg}/100** across ${scored.length} doctor${scored.length === 1 ? "" : "s"}.`);
+    lines.push("");
+    lines.push(`| Doctor | Status | Score | Notes |`);
+    lines.push(`|---|---|---|---|`);
+    for (const r of runs) {
+        if (!r.enabled) {
+            lines.push(`| \`${r.name}\` | skipped | — | ${r.reason ?? ""} |`);
+        }
+        else if (r.error) {
+            lines.push(`| \`${r.name}\` | failed | — | ${r.error} |`);
+        }
+        else {
+            lines.push(`| \`${r.name}\` | ok | ${r.score ?? "—"}/100 | ${r.grade ?? ""} |`);
+        }
+    }
+    lines.push("");
+    for (const r of enabled) {
+        if (r.error || !r.output)
+            continue;
+        lines.push(`### ${r.name}`);
+        lines.push("");
+        lines.push("Run individually for full output:");
+        lines.push("```");
+        lines.push(`npx -y ${r.name}@latest scan .`);
+        lines.push("```");
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/reporters/tty.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTty = renderTty;
+const C = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    red: "\x1b[31m", yellow: "\x1b[33m", green: "\x1b[32m", cyan: "\x1b[36m",
+};
+function renderTty(runs, opts = { noColor: false }) {
+    const c = opts.noColor ? blank() : C;
+    const out = (s) => process.stdout.write(s + "\n");
+    out(`${c.bold}doctors${c.reset} ${c.dim}— suite report${c.reset}`);
+    out("");
+    // Aggregate
+    const enabled = runs.filter((r) => r.enabled);
+    const scored = enabled.filter((r) => typeof r.score === "number");
+    const avg = scored.length ? Math.round(scored.reduce((s, r) => s + (r.score ?? 0), 0) / scored.length) : null;
+    for (const r of runs) {
+        if (!r.enabled) {
+            out(`  ${c.dim}skip${c.reset} ${r.name.padEnd(15)} ${c.dim}— ${r.reason}${c.reset}`);
+            continue;
+        }
+        if (r.error) {
+            out(`  ${c.red}fail${c.reset} ${r.name.padEnd(15)} ${c.red}${r.error}${c.reset}  ${c.dim}(${r.durationMs}ms)${c.reset}`);
+            continue;
+        }
+        const score = r.score ?? 0;
+        const sc = score >= 75 ? c.green : score >= 50 ? c.yellow : c.red;
+        out(`  ${c.green}ok${c.reset}   ${r.name.padEnd(15)} ${sc}${c.bold}${score}${c.reset}/100 ${sc}${r.grade ?? ""}${c.reset}  ${c.dim}(${r.durationMs}ms)${c.reset}`);
+    }
+    out("");
+    if (avg !== null) {
+        const sc = avg >= 75 ? c.green : avg >= 50 ? c.yellow : c.red;
+        out(`  ${c.bold}Suite average:${c.reset} ${sc}${c.bold}${avg}/100${c.reset}  ${c.dim}across ${scored.length} doctor${scored.length === 1 ? "" : "s"}${c.reset}`);
+    }
+    else {
+        out(`  ${c.dim}No doctors produced a parseable score.${c.reset}`);
+    }
+}
+function blank() {
+    const o = { reset: "", bold: "", dim: "", red: "", yellow: "", green: "", cyan: "" };
+    return o;
+}

package/dist/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+exports.VERSION = "0.1.0";

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "four-doctors",
+  "version": "0.1.0",
+  "description": "Run rails-doctor, design-doctor, react-doctor, and qa-doctor with one command. Auto-detects which apply, aggregates the scores into a single report, and installs all four agent skills at once.",
+  "keywords": [
+    "rails-doctor",
+    "design-doctor",
+    "qa-doctor",
+    "react-doctor",
+    "static-analysis",
+    "browser-testing",
+    "claude-code",
+    "codex",
+    "agent-skill",
+    "monorepo",
+    "audit"
+  ],
+  "homepage": "https://github.com/artisanscompany/doctors",
+  "bugs": { "url": "https://github.com/artisanscompany/doctors/issues" },
+  "repository": { "type": "git", "url": "git+https://github.com/artisanscompany/doctors.git" },
+  "license": "MIT",
+  "author": "ArtisansCompany",
+  "bin": { "four-doctors": "bin/doctors.js" },
+  "engines": { "node": ">=18" },
+  "files": ["bin/", "dist/", "skills/", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  }
+}

package/skills/doctors/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: doctors
+description: Use when the user wants a full health check of a Rails+Inertia or TanStack codebase — runs rails-doctor, design-doctor, qa-doctor (browser), and optionally react-doctor, and aggregates the scores into one report. Auto-skips inapplicable doctors. Useful before committing, before a release, or when onboarding a new codebase.
+version: "1.0.0"
+---
+
+# Doctors
+
+The whole suite, one command. Runs every applicable doctor against the project, aggregates the scores, and emits a single report.
+
+## Quick start
+
+```bash
+npx -y doctors@latest scan .
+```
+
+That runs `rails-doctor` (if a Gemfile is present) and `design-doctor` (if React is in `package.json`), shows individual scores plus the suite average.
+
+## Add browser QA
+
+```bash
+npx -y doctors@latest scan . --browser --url http://localhost:3000
+```
+
+Adds `qa-doctor` to the run. Needs a running dev server.
+
+## Add vision pass
+
+```bash
+npx -y doctors@latest scan . --vision --url http://localhost:3000
+```
+
+Runs `design-doctor` with the LLM vision pass enabled.
+
+## Run all four
+
+```bash
+npx -y doctors@latest scan . --browser --vision --fill --url http://localhost:3000 --react-doctor
+```
+
+## Companion install
+
+Install every individual doctor's skill at once:
+
+```bash
+npx -y rails-doctor@latest install
+npx -y design-doctor@latest install
+npx -y qa-doctor@latest install
+npx -y doctors@latest install
+```
+
+After that, an agent can call any of them by name; this skill just helps the agent decide which to run together.
+
+## CI gating
+
+```bash
+npx -y doctors@latest scan . --min-score 80
+```
+
+Fails the build when the suite average drops below 80.
+
+## What each doctor scores
+
+| Doctor          | Surface                                                           |
+|-----------------|-------------------------------------------------------------------|
+| `rails-doctor`  | Ruby / Rails — routes, models, migrations, security, Inertia, perf |
+| `design-doctor` | React — design tokens, microcopy, a11y, shadcn use, vision        |
+| `qa-doctor`     | Live browser — feature pass/fail, form-fill, retries              |
+| `react-doctor`  | Third-party — general React lint, dead code, bundle               |
+
+## Distribution
+
+npm. Pure Node. Works with Node 18+.