@dgr_labs/bezelbub-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DGR Labs, LLC
+
+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,134 @@
+# @dgr_labs/bezelbub-mcp
+
+MCP (Model Context Protocol) server for [Bezelbub](https://dgrlabs.co): frame
+screenshots and screen recordings in realistic Apple device bezels — iPhone,
+iPad, MacBook, iMac, and Apple TV device mockups — straight from an AI
+assistant. Supports transparent HEVC-with-alpha video export (with an optional
+VP9/WebM copy for Chrome/Firefox).
+
+The server is a thin stdio adapter over the `bezelbub` CLI: every tool shells
+out to the CLI in `--json` mode, and the CLI's exit codes and suggestion-rich
+stderr are surfaced as MCP tool errors.
+
+> **macOS only.** The Bezelbub engine is a macOS-native binary (Core Graphics /
+> AVFoundation), so this server runs only on a Mac. The npm package declares
+> `"os": ["darwin"]` and will refuse to install elsewhere.
+
+## Prerequisites
+
+- macOS 14+
+- Node.js 18+
+- The `bezelbub` CLI:
+
+```sh
+brew install cwooddgr/tap/bezelbub
+```
+
+The server finds the CLI via the `BEZELBUB_CLI_PATH` environment variable if
+set, otherwise on `PATH` (plus the standard Homebrew locations
+`/opt/homebrew/bin` and `/usr/local/bin`, since GUI apps launch MCP servers
+with a minimal `PATH`).
+
+## Setup
+
+### Claude Code
+
+```sh
+claude mcp add bezelbub -- npx -y @dgr_labs/bezelbub-mcp
+```
+
+### Claude Desktop
+
+Open the config file (Claude menu › Settings… › Developer › Edit Config), which
+lives at `~/Library/Application Support/Claude/claude_desktop_config.json`, and
+add:
+
+```json
+{
+  "mcpServers": {
+    "bezelbub": {
+      "command": "npx",
+      "args": ["-y", "@dgr_labs/bezelbub-mcp"]
+    }
+  }
+}
+```
+
+Then restart Claude Desktop.
+
+### Desktop Extension (.mcpb)
+
+The repo includes a `manifest.json` conforming to the
+[MCPB](https://github.com/modelcontextprotocol/mcpb) spec. To build a
+one-click-installable bundle:
+
+```sh
+npm ci && npm run build
+npx @anthropic-ai/mcpb pack
+```
+
+## Tools
+
+### `frame_image`
+
+Frame a screenshot in a device bezel; writes a framed PNG.
+
+| Parameter | Required | Description |
+|---|---|---|
+| `input_path` | yes | Absolute path to a PNG/JPEG/HEIC screenshot |
+| `device` | no | Device id (e.g. `iphone17pro`); auto-detected from pixel size when omitted |
+| `color` | no | Bezel color name (e.g. `Cosmic Orange`); device default when omitted |
+| `orientation` | no | `portrait` \| `landscape` \| `auto` (default) |
+| `background` | no | Hex color (`#FFFFFF`, `#RRGGBBAA`) or `transparent` (default) |
+| `output_size` | no | Width (`1920`), exact size (`1920x988`), or percentage (`50%`) |
+| `output_path` | no | Defaults to `<input>-framed.png` beside the input |
+
+Returns JSON: `{kind: "image", device, color, orientation, output, width, height}`.
+
+### `frame_video`
+
+Frame a screen recording (`.mov`/`.mp4`/`.m4v`) in a device bezel; writes a
+framed MP4 with audio preserved. `background: "transparent"` switches the
+export to HEVC-with-alpha in a QuickTime `.mov` (plays in Safari and Apple
+frameworks only); `webm: true` additionally writes a VP9/WebM copy for
+Chrome/Firefox (requires `ffmpeg` on `PATH`).
+
+Same parameters as `frame_image`, plus `webm` (boolean); `background` defaults
+to black for video. Returns JSON:
+`{kind: "video", transparent, output, webm?, device, color, orientation, width, height}`.
+
+### `list_devices`
+
+List the 38-device bezel catalog (ids, colors, screen pixel sizes), or — with
+`input_path` or `dimensions` (`"1206x2622"`) — find which devices fit a given
+screenshot, recording, or pixel size. Filtered results return
+`{width, height, matches, nearest}`; an empty `matches` array means no exact
+fit and `nearest` lists the closest devices by aspect ratio.
+
+## Error handling
+
+CLI failures come back as MCP tool errors carrying the CLI's stderr — which
+already includes concrete fixes (valid device ids, a device's color list,
+nearest screen sizes) — plus the documented meaning of the exit code (2 unknown
+or ambiguous device, 3 unknown color, 4 unreadable input, 5 composite/export
+failed, 6 write failed, 7 ffmpeg missing for `--webm`).
+
+## Environment variables
+
+| Variable | Purpose |
+|---|---|
+| `BEZELBUB_CLI_PATH` | Explicit path to the `bezelbub` binary (overrides `PATH` lookup) |
+| `BEZELBUB_TIMEOUT_MS` | Per-call CLI timeout in milliseconds (default 600000; raise for long video exports) |
+
+## Development
+
+```sh
+npm ci
+npm run build      # tsc → dist/
+npm test           # builds, then runs an end-to-end MCP-over-stdio test
+                   # (requires the bezelbub CLI; generates its own test image)
+```
+
+## License
+
+MIT © DGR Labs

package/dist/cli.js

@@ -0,0 +1,111 @@
+/**
+ * Resolution and execution of the `bezelbub` CLI binary.
+ *
+ * The MCP server is a thin adapter: every tool call shells out to
+ * `bezelbub` in `--json` mode and maps its exit codes / stderr to
+ * MCP tool errors.
+ */
+import { execFile } from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import { delimiter, join } from "node:path";
+const BREW_HINT = "Install it with: brew install cwooddgr/tap/bezelbub — or point the " +
+    "BEZELBUB_CLI_PATH environment variable at a bezelbub binary.";
+/** Directories checked even when they are missing from PATH (GUI apps like
+ *  Claude Desktop launch MCP servers with a minimal PATH that often lacks
+ *  the Homebrew bin directory). */
+const FALLBACK_DIRS = ["/opt/homebrew/bin", "/usr/local/bin"];
+/** Exit-code meanings documented in `bezelbub --help`. */
+const EXIT_MEANINGS = {
+    1: "invalid flag value",
+    2: "unknown, ambiguous, or undetectable device",
+    3: "unknown color",
+    4: "input image or video unreadable",
+    5: "compositing or video export failed",
+    6: "output could not be written",
+    7: "WebM conversion failed (ffmpeg missing from PATH, or ffmpeg errored)",
+    64: "malformed arguments",
+};
+let cachedBinary;
+function isExecutable(path) {
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Locate the bezelbub binary.
+ * Order: BEZELBUB_CLI_PATH env var → `bezelbub` on PATH (plus the standard
+ * Homebrew bin dirs) → error telling the user how to install it.
+ */
+export function resolveBinary() {
+    if (process.platform !== "darwin") {
+        throw new Error("Bezelbub is macOS-only: the bezelbub CLI is a macOS-native binary " +
+            "(Core Graphics / AVFoundation). Run this MCP server on a Mac.");
+    }
+    if (cachedBinary)
+        return cachedBinary;
+    const envPath = process.env.BEZELBUB_CLI_PATH?.trim();
+    // "${..." guards against an MCPB host passing through an unresolved
+    // ${user_config...} placeholder when the user left the setting blank.
+    if (envPath && !envPath.startsWith("${")) {
+        if (!isExecutable(envPath)) {
+            throw new Error(`BEZELBUB_CLI_PATH is set to "${envPath}" but no executable exists there. ` +
+                BREW_HINT);
+        }
+        cachedBinary = envPath;
+        return envPath;
+    }
+    const pathDirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+    for (const dir of [...pathDirs, ...FALLBACK_DIRS]) {
+        const candidate = join(dir, "bezelbub");
+        if (isExecutable(candidate)) {
+            cachedBinary = candidate;
+            return candidate;
+        }
+    }
+    throw new Error("The bezelbub CLI was not found on PATH. " + BREW_HINT);
+}
+/**
+ * Run `bezelbub <args> --json`. Resolves with parsed JSON on success;
+ * throws an Error whose message carries the CLI's stderr (which already
+ * contains concrete suggestions — valid ids, nearest devices, etc.) plus
+ * the documented meaning of the exit code.
+ */
+export function runBezelbub(args, timeoutMs = Number(process.env.BEZELBUB_TIMEOUT_MS) || 10 * 60 * 1000) {
+    const binary = resolveBinary();
+    return new Promise((resolve, reject) => {
+        execFile(binary, [...args, "--json"], { timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (!error) {
+                let json = stdout;
+                try {
+                    json = JSON.parse(stdout);
+                }
+                catch {
+                    /* leave raw */
+                }
+                resolve({ json, stdout });
+                return;
+            }
+            const anyErr = error;
+            if (anyErr.code === "ENOENT") {
+                reject(new Error(`Could not execute bezelbub at "${binary}". ${BREW_HINT}`));
+                return;
+            }
+            if (anyErr.killed || anyErr.signal) {
+                reject(new Error(`bezelbub timed out after ${Math.round(timeoutMs / 1000)}s ` +
+                    `(signal ${anyErr.signal}). Long video exports may need a larger ` +
+                    `timeout: set the BEZELBUB_TIMEOUT_MS environment variable.`));
+                return;
+            }
+            const code = typeof anyErr.code === "number" ? anyErr.code : undefined;
+            const meaning = code !== undefined && EXIT_MEANINGS[code]
+                ? ` (${EXIT_MEANINGS[code]})`
+                : "";
+            const detail = (stderr || stdout || "no error output").trim();
+            reject(new Error(`bezelbub exited with code ${code}${meaning}:\n${detail}`));
+        });
+    });
+}

package/dist/index.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+/**
+ * bezelbub-mcp — MCP server wrapping the `bezelbub` CLI.
+ *
+ * Composites Apple device bezels onto screenshots and screen recordings.
+ * macOS-only (the CLI is a macOS-native binary). Every tool shells out to
+ * `bezelbub --json`; see src/cli.ts for binary resolution and error mapping.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { resolve as resolvePath } from "node:path";
+import { runBezelbub } from "./cli.js";
+const SERVER_VERSION = "0.1.0";
+const server = new McpServer({
+    name: "bezelbub",
+    version: SERVER_VERSION,
+});
+/** Shared framing options (image + video). */
+const framingShape = {
+    input_path: z
+        .string()
+        .describe("Absolute path to the input file. Relative paths are resolved against " +
+        "the MCP server's working directory, so prefer absolute paths."),
+    device: z
+        .string()
+        .optional()
+        .describe("Device id, e.g. 'iphone17pro', 'ipadpro13m5', 'macbookpro14'. Omit to " +
+        "auto-detect from the input's pixel size; if several devices share " +
+        "that resolution the error lists the candidates. Use list_devices " +
+        "for valid ids."),
+    color: z
+        .string()
+        .optional()
+        .describe("Bezel color name, e.g. 'Silver', 'Cosmic Orange'. Defaults to the " +
+        "device's default color. Invalid colors error with the valid list."),
+    orientation: z
+        .enum(["portrait", "landscape", "auto"])
+        .optional()
+        .describe("Bezel orientation. Default 'auto' (inferred from the input)."),
+    output_size: z
+        .string()
+        .optional()
+        .describe("Scale the output, preserving the bezel's aspect ratio: a width " +
+        "('1920'), an exact size ('1920x988'), or a percentage of native " +
+        "size ('50%'). Default: the bezel's native size."),
+    output_path: z
+        .string()
+        .optional()
+        .describe("Absolute path for the output file. Defaults to '<input>-framed.png' " +
+        "(image) or '<input>-framed.mp4' / '.mov' (video) beside the input."),
+};
+function framingFlags(args) {
+    const flags = ["frame", "--input", resolvePath(args.input_path)];
+    if (args.device)
+        flags.push("--device", args.device);
+    if (args.color)
+        flags.push("--color", args.color);
+    if (args.orientation)
+        flags.push("--orientation", args.orientation);
+    if (args.output_size)
+        flags.push("--output-size", args.output_size);
+    if (args.output_path)
+        flags.push("--output", resolvePath(args.output_path));
+    return flags;
+}
+function ok(json, stdout) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: typeof json === "string" ? stdout : JSON.stringify(json, null, 2),
+            },
+        ],
+    };
+}
+function fail(error) {
+    return {
+        content: [
+            { type: "text", text: error instanceof Error ? error.message : String(error) },
+        ],
+        isError: true,
+    };
+}
+server.registerTool("frame_image", {
+    title: "Frame a screenshot in a device bezel",
+    description: "Frame a screenshot in an Apple device bezel — i.e. make a device " +
+        "mockup: put a screenshot inside a realistic iPhone, iPad, Mac, iMac, " +
+        "or Apple TV frame. Use for requests like 'frame this screenshot in an " +
+        "iPhone bezel', 'device mockup', 'make this look like it's on an iPad', " +
+        "or App Store / marketing imagery. Input: PNG, JPEG, or HEIC file on " +
+        "disk. Output: a framed PNG written next to the input (or at " +
+        "output_path); the background around the bezel is transparent unless a " +
+        "hex color is given. The device is auto-detected from the screenshot's " +
+        "pixel size when 'device' is omitted. Returns JSON with the output " +
+        "path, device, color, orientation, and final pixel size. macOS only.",
+    inputSchema: {
+        ...framingShape,
+        background: z
+            .string()
+            .optional()
+            .describe("Background fill behind/around the bezel: a hex color like " +
+            "'#FFFFFF' or '#RRGGBBAA', or 'transparent'. Default: transparent."),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async (args) => {
+    try {
+        const flags = framingFlags(args);
+        if (args.background)
+            flags.push("--background", args.background);
+        const { json, stdout } = await runBezelbub(flags);
+        return ok(json, stdout);
+    }
+    catch (error) {
+        return fail(error);
+    }
+});
+server.registerTool("frame_video", {
+    title: "Frame a screen recording in a device bezel",
+    description: "Frame a screen recording (video) in an Apple device bezel — a video " +
+        "device mockup: put an iPhone/iPad/Mac screen recording inside a " +
+        "realistic device frame, preserving the audio track. Use for requests " +
+        "like 'frame this screen recording in an iPhone bezel', 'app demo " +
+        "video in a device frame', or 'transparent video with alpha for my " +
+        "website'. Input: .mov, .mp4, or .m4v file on disk. Output: a framed " +
+        "MP4 (background defaults to black), or — with background " +
+        "'transparent' — an HEVC-with-alpha QuickTime .mov whose surroundings " +
+        "are truly transparent (plays in Safari and Apple frameworks only; set " +
+        "webm=true to also write a VP9/WebM copy for Chrome/Firefox, which " +
+        "requires ffmpeg on PATH). Device is auto-detected from the video's " +
+        "pixel size when 'device' is omitted. Returns JSON with the output " +
+        "path(s) and final pixel size. Long videos can take minutes. macOS only.",
+    inputSchema: {
+        ...framingShape,
+        background: z
+            .string()
+            .optional()
+            .describe("Background fill: a hex color like '#1D1D1F', or 'transparent'. " +
+            "Default: black. 'transparent' switches the export to " +
+            "HEVC-with-alpha in a QuickTime .mov (Safari/Apple playback only)."),
+        webm: z
+            .boolean()
+            .optional()
+            .describe("Also write a VP9/WebM copy of a transparent export for " +
+            "Chrome/Firefox playback. Requires background='transparent' and " +
+            "ffmpeg on PATH."),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async (args) => {
+    try {
+        const flags = framingFlags(args);
+        if (args.background)
+            flags.push("--background", args.background);
+        if (args.webm)
+            flags.push("--webm");
+        const { json, stdout } = await runBezelbub(flags);
+        return ok(json, stdout);
+    }
+    catch (error) {
+        return fail(error);
+    }
+});
+server.registerTool("list_devices", {
+    title: "List device bezels / match a screenshot to devices",
+    description: "List the Apple device bezels available for framing (iPhones, iPads, " +
+        "MacBooks, iMac, Apple TV) with their ids, color options, and screen " +
+        "pixel sizes — or find which devices fit a given screenshot, screen " +
+        "recording, or WxH pixel size ('which iPhone matches a 1206x2622 " +
+        "screenshot?'). With input_path or dimensions, returns {width, height, " +
+        "matches, nearest}: 'matches' are exact screen-size fits (empty means " +
+        "no device fits; 'nearest' then lists the closest by aspect ratio). " +
+        "Without a filter, returns the full device catalog. Use this before " +
+        "frame_image/frame_video when the device or color is ambiguous. " +
+        "macOS only.",
+    inputSchema: {
+        input_path: z
+            .string()
+            .optional()
+            .describe("Absolute path to a screenshot or video: filters the list to " +
+            "devices whose screen matches its pixel size."),
+        dimensions: z
+            .string()
+            .optional()
+            .describe("Filter by a pixel size like '1206x2622' (width x height) without " +
+            "needing a file on disk. Ignored if input_path is given."),
+    },
+    annotations: {
+        readOnlyHint: true,
+        openWorldHint: false,
+    },
+}, async (args) => {
+    try {
+        const flags = ["devices"];
+        if (args.input_path)
+            flags.push("--input", resolvePath(args.input_path));
+        else if (args.dimensions)
+            flags.push("--dimensions", args.dimensions);
+        const { json, stdout } = await runBezelbub(flags);
+        return ok(json, stdout);
+    }
+    catch (error) {
+        return fail(error);
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`bezelbub-mcp ${SERVER_VERSION} ready (stdio)`);
+}
+main().catch((error) => {
+    console.error("bezelbub-mcp fatal:", error);
+    process.exit(1);
+});

package/manifest.json

@@ -0,0 +1,70 @@
+{
+  "manifest_version": "0.3",
+  "name": "bezelbub-mcp",
+  "display_name": "Bezelbub",
+  "version": "0.1.0",
+  "description": "Frame screenshots and screen recordings in Apple device bezels (iPhone, iPad, Mac, iMac, Apple TV mockups).",
+  "long_description": "Bezelbub composites realistic Apple device bezels onto screenshots and screen recordings — device mockups for App Store pages, marketing sites, and demo videos.\n\nTools: frame a screenshot as a framed PNG, frame a screen recording as a framed MP4 (or a transparent HEVC-with-alpha .mov, with an optional VP9/WebM copy for Chrome/Firefox), and list/match the device catalog (38 devices: iPhone 14–17 families, iPads, MacBooks, iMac, Apple TV).\n\nRequires the bezelbub CLI on this Mac: `brew install cwooddgr/tap/bezelbub`. macOS only — the engine is a macOS-native binary.",
+  "author": {
+    "name": "DGR Labs",
+    "url": "https://dgrlabs.co"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cwooddgr/bezelbub.git"
+  },
+  "homepage": "https://dgrlabs.co",
+  "keywords": [
+    "bezel",
+    "device mockup",
+    "device frame",
+    "screenshot",
+    "screen recording",
+    "iphone",
+    "ipad",
+    "mac",
+    "app store",
+    "transparent video",
+    "hevc alpha"
+  ],
+  "license": "MIT",
+  "server": {
+    "type": "node",
+    "entry_point": "dist/index.js",
+    "mcp_config": {
+      "command": "node",
+      "args": ["${__dirname}/dist/index.js"],
+      "env": {
+        "BEZELBUB_CLI_PATH": "${user_config.bezelbub_cli_path}"
+      }
+    }
+  },
+  "user_config": {
+    "bezelbub_cli_path": {
+      "type": "file",
+      "title": "bezelbub CLI path",
+      "description": "Path to the bezelbub binary. Leave blank if it is installed via Homebrew (brew install cwooddgr/tap/bezelbub) — the server finds it in /opt/homebrew/bin or /usr/local/bin automatically.",
+      "required": false
+    }
+  },
+  "tools": [
+    {
+      "name": "frame_image",
+      "description": "Frame a screenshot in an Apple device bezel (device mockup); writes a framed PNG."
+    },
+    {
+      "name": "frame_video",
+      "description": "Frame a screen recording in a device bezel; framed MP4, or transparent HEVC-alpha .mov with optional WebM copy."
+    },
+    {
+      "name": "list_devices",
+      "description": "List available device bezels, or match a screenshot/recording/pixel size to devices."
+    }
+  ],
+  "compatibility": {
+    "platforms": ["darwin"],
+    "runtimes": {
+      "node": ">=18.0.0"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@dgr_labs/bezelbub-mcp",
+  "version": "0.1.0",
+  "mcpName": "io.github.cwooddgr/bezelbub-mcp",
+  "description": "MCP server for Bezelbub: frame screenshots and screen recordings in Apple device bezels (iPhone, iPad, Mac, iMac, Apple TV device mockups), including transparent HEVC-alpha video export. macOS only.",
+  "type": "module",
+  "bin": {
+    "bezelbub-mcp": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "manifest.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "npm run build && node test/e2e.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mcp-server",
+    "bezel",
+    "device-mockup",
+    "device-frame",
+    "screenshot",
+    "screen-recording",
+    "iphone",
+    "ipad",
+    "mac",
+    "app-store",
+    "hevc-alpha",
+    "transparent-video",
+    "macos"
+  ],
+  "author": {
+    "name": "DGR Labs",
+    "url": "https://dgrlabs.co"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cwooddgr/bezelbub.git",
+    "directory": "bezelbub-mcp"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "typescript": "^7.0.2"
+  }
+}