@harperfast/harper 5.0.25 → 5.1.0-beta.1

package/components/mcp/index.ts

@@ -0,0 +1,134 @@
+/**
+ * Native MCP (Model Context Protocol) server component for Harper.
+ *
+ * #614 replaces the foundation stub from #613 with a real Streamable HTTP
+ * transport. Two entry points:
+ *
+ *   - `registerMcpProfile({profile:'operations', host, config, routeOptions})`
+ *     called from `server/operationsServer.ts` (Fastify-side gate).
+ *
+ *   - `handleApplication(scope)` invoked by the component loader when the
+ *     root config contains a top-level `mcp:` block. Registers the
+ *     application-profile handler on the HTTP port iff `mcp.application` is
+ *     present.
+ *
+ * Profile presence drives enablement, matching Harper's `replication`
+ * convention (no `enabled` flag). See #465 for the umbrella design.
+ */
+import harperLogger from '../../utility/logging/harper_logger.ts';
+import { getConfigObj as realGetConfigObj } from '../../config/configUtils.js';
+import { createFastifyHandler } from './adapters/fastify.ts';
+import { createHarperHttpHandler } from './adapters/harperHttp.ts';
+import { ensureSessionTable } from './session.ts';
+import { initListChanged } from './listChanged.ts';
+import { registerApplicationTools } from './tools/application.ts';
+import { registerOperationsTools } from './tools/operations.ts';
+import type { McpProfile } from './transport.ts';
+
+// Indirection so tests can swap the config source.
+let getConfigObj: () => unknown = realGetConfigObj as () => unknown;
+export function _setGetConfigObjForTest(fn: () => unknown): void {
+	getConfigObj = fn;
+}
+export function _restoreGetConfigObj(): void {
+	getConfigObj = realGetConfigObj as () => unknown;
+}
+
+interface McpProfileConfig {
+	mountPath?: string;
+}
+
+interface FullConfig {
+	mcp?: {
+		operations?: McpProfileConfig;
+		application?: McpProfileConfig;
+		session?: unknown;
+	};
+}
+
+interface FastifyLikeHost {
+	post: (path: string, ...rest: unknown[]) => unknown;
+	get: (path: string, ...rest: unknown[]) => unknown;
+	delete: (path: string, ...rest: unknown[]) => unknown;
+}
+
+export interface RegisterMcpProfileArgs {
+	profile: McpProfile;
+	host: FastifyLikeHost;
+	config: FullConfig;
+	routeOptions?: Record<string, unknown>;
+}
+
+const DEFAULT_MOUNT_PATH = '/mcp';
+
+/**
+ * Fastify-side registration. Used by `server/operationsServer.ts` for the
+ * operations profile. Idempotent through the host's own route table.
+ */
+export function registerMcpProfile({ profile, host, config, routeOptions }: RegisterMcpProfileArgs): void {
+	const profileConfig = config?.mcp?.[profile];
+	if (!profileConfig) {
+		harperLogger.trace(`MCP ${profile} profile not configured, skipping registration`);
+		return;
+	}
+	ensureSessionTable();
+	initListChanged();
+	if (profile === 'operations') {
+		registerOperationsTools();
+	}
+	const mountPath = profileConfig.mountPath ?? DEFAULT_MOUNT_PATH;
+	const handler = createFastifyHandler(profile);
+	// Register POST, GET, and DELETE on the same mount path. The transport
+	// core decides whether to handle (POST initialize / JSON-RPC dispatch),
+	// return 405 with an accurate `Allow` header (GET always in v1, DELETE
+	// when `mcp.session.allowClientDelete` is false), or process (DELETE
+	// when enabled). Without explicit GET/DELETE routes Fastify would
+	// short-circuit to its built-in 404 before the transport runs.
+	for (const method of ['post', 'get', 'delete'] as const) {
+		if (routeOptions) {
+			host[method](mountPath, routeOptions, handler);
+		} else {
+			host[method](mountPath, handler);
+		}
+	}
+	harperLogger.info(`MCP ${profile} profile registered at ${mountPath}`);
+}
+
+let applicationStarted = false;
+
+interface ScopeLike {
+	server: {
+		http: (handler: unknown, options: Record<string, unknown>) => unknown;
+	};
+}
+
+/**
+ * Trusted-Resource-Plugin entry point for the application profile. The
+ * component loader invokes this with the runtime `Scope` when the root
+ * config contains a top-level `mcp:` block. We register the handler iff the
+ * `application` sub-block is also present.
+ *
+ * Idempotent — repeated invocations no-op via `applicationStarted`. This
+ * matches REST's pattern at `server/REST.ts:283-303`.
+ */
+export function handleApplication(scope: ScopeLike): void {
+	if (applicationStarted) return;
+	const config = getConfigObj() as FullConfig | undefined;
+	if (!config?.mcp?.application) {
+		harperLogger.trace('MCP application profile not configured, skipping registration');
+		return;
+	}
+	applicationStarted = true;
+	ensureSessionTable();
+	initListChanged();
+	registerApplicationTools();
+	const mountPath = config.mcp.application.mountPath ?? DEFAULT_MOUNT_PATH;
+	const handler = createHarperHttpHandler('application');
+	scope.server.http(handler, { urlPath: mountPath, after: 'authentication' });
+	harperLogger.info(`MCP application profile registered at ${mountPath}`);
+}
+
+/** Test seam: reset the module-level guard so tests can re-invoke handleApplication. */
+export function _resetApplicationStartedForTest(): void {
+	applicationStarted = false;
+}

package/components/mcp/jsonrpc.ts

@@ -0,0 +1,134 @@
+/**
+ * JSON-RPC 2.0 envelope parsing + error helpers for the MCP Streamable HTTP
+ * transport (#614). The MCP wire format is one JSON-RPC message per HTTP body
+ * (no batches in the 2025-06-18 revision — spec §transports).
+ *
+ * Spec: https://www.jsonrpc.org/specification
+ */
+
+export const JSONRPC_VERSION = '2.0';
+
+/** Standard JSON-RPC 2.0 error codes (spec §5.1). */
+export const ERROR_CODES = {
+	PARSE_ERROR: -32700,
+	INVALID_REQUEST: -32600,
+	METHOD_NOT_FOUND: -32601,
+	INVALID_PARAMS: -32602,
+	INTERNAL_ERROR: -32603,
+} as const;
+
+export type JsonRpcId = string | number | null;
+
+export interface JsonRpcRequest {
+	jsonrpc: '2.0';
+	id: JsonRpcId;
+	method: string;
+	params?: unknown;
+}
+
+export interface JsonRpcNotification {
+	jsonrpc: '2.0';
+	method: string;
+	params?: unknown;
+}
+
+export interface JsonRpcSuccessResponse {
+	jsonrpc: '2.0';
+	id: JsonRpcId;
+	result: unknown;
+}
+
+export interface JsonRpcErrorObject {
+	code: number;
+	message: string;
+	data?: unknown;
+}
+
+export interface JsonRpcErrorResponse {
+	jsonrpc: '2.0';
+	id: JsonRpcId;
+	error: JsonRpcErrorObject;
+}
+
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcSuccessResponse | JsonRpcErrorResponse;
+
+export interface ParseSuccess {
+	ok: true;
+	message: JsonRpcMessage;
+}
+export interface ParseFailure {
+	ok: false;
+	code: number;
+	reason: string;
+}
+export type ParseResult = ParseSuccess | ParseFailure;
+
+/**
+ * Validate a JSON-RPC envelope. Accepts either a raw UTF-8 JSON string
+ * (e.g., from a streamed request body) or an already-parsed value (e.g.,
+ * Fastify hands us a parsed object via its preParsing pipeline). Returns
+ * either a typed message or a structured parse error that the caller maps
+ * to a JSON-RPC error response. Never throws.
+ */
+export function parseMessage(body: string | unknown): ParseResult {
+	let parsed: unknown;
+	if (typeof body === 'string') {
+		try {
+			parsed = JSON.parse(body);
+		} catch (err) {
+			const fail: ParseFailure = { ok: false, code: ERROR_CODES.PARSE_ERROR, reason: (err as Error).message };
+			return fail;
+		}
+	} else {
+		parsed = body;
+	}
+	if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+		// Batch requests (arrays) are not used in the MCP Streamable HTTP wire
+		// format; rejecting them keeps the transport unambiguous.
+		const fail: ParseFailure = { ok: false, code: ERROR_CODES.INVALID_REQUEST, reason: 'expected a JSON object' };
+		return fail;
+	}
+	const obj = parsed as Record<string, unknown>;
+	if (obj.jsonrpc !== JSONRPC_VERSION) {
+		const fail: ParseFailure = {
+			ok: false,
+			code: ERROR_CODES.INVALID_REQUEST,
+			reason: `jsonrpc must be "${JSONRPC_VERSION}"`,
+		};
+		return fail;
+	}
+	const hasMethod = typeof obj.method === 'string';
+	const hasResultOrError = 'result' in obj || 'error' in obj;
+	if (!hasMethod && !hasResultOrError) {
+		const fail: ParseFailure = {
+			ok: false,
+			code: ERROR_CODES.INVALID_REQUEST,
+			reason: 'missing method, result, or error field',
+		};
+		return fail;
+	}
+	const success: ParseSuccess = { ok: true, message: parsed as JsonRpcMessage };
+	return success;
+}
+
+/**
+ * True if the message is a "fire-and-forget" frame from the client's
+ * perspective — a notification (no `id`) or a response to a server-initiated
+ * request (has `result` or `error`). Per MCP §transports point 4, both yield
+ * HTTP 202 with no body.
+ */
+export function isClientFireAndForget(message: JsonRpcMessage): boolean {
+	const hasId = 'id' in message;
+	const hasResultOrError = 'result' in message || 'error' in message;
+	return !hasId || hasResultOrError;
+}
+
+export function buildSuccess(id: JsonRpcId, result: unknown): JsonRpcSuccessResponse {
+	return { jsonrpc: JSONRPC_VERSION, id, result };
+}
+
+export function buildError(id: JsonRpcId, code: number, message: string, data?: unknown): JsonRpcErrorResponse {
+	const error: JsonRpcErrorObject = { code, message };
+	if (data !== undefined) error.data = data;
+	return { jsonrpc: JSONRPC_VERSION, id, error };
+}

package/components/mcp/lifecycle.ts

@@ -0,0 +1,105 @@
+/**
+ * MCP lifecycle handlers — `initialize` and `notifications/initialized`.
+ *
+ * Spec: https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle
+ * v1 supports protocol version `2025-06-18` (preferred) and `2025-03-26`
+ * (backcompat). Anything else returns 400 to the client; per the spec, the
+ * server SHOULD respond with its preferred supported version so the client
+ * can decide whether to connect on the older version or disconnect.
+ */
+import { createSession, saveSession, type McpSessionRecord } from './session.ts';
+import { packageJson } from '../../utility/packageUtils.js';
+
+export const PROTOCOL_VERSION_PREFERRED = '2025-06-18';
+export const PROTOCOL_VERSION_BACKCOMPAT = '2025-03-26';
+export const SUPPORTED_PROTOCOL_VERSIONS = [PROTOCOL_VERSION_PREFERRED, PROTOCOL_VERSION_BACKCOMPAT] as const;
+
+export const SERVER_INFO = {
+	name: 'harper-mcp',
+	version: (packageJson as { version: string }).version,
+} as const;
+
+/** Server capabilities advertised on `initialize` for v1. */
+export const SERVER_CAPABILITIES = {
+	tools: { listChanged: true },
+	resources: { listChanged: true },
+	logging: {},
+} as const;
+
+export interface InitializeParams {
+	protocolVersion?: unknown;
+	capabilities?: unknown;
+	clientInfo?: unknown;
+}
+
+export interface InitializeResult {
+	protocolVersion: string;
+	serverInfo: typeof SERVER_INFO;
+	capabilities: typeof SERVER_CAPABILITIES;
+	instructions?: string;
+}
+
+export interface InitializeOutcome {
+	ok: true;
+	session: McpSessionRecord;
+	result: InitializeResult;
+}
+
+export interface InitializeFailure {
+	ok: false;
+	reason: string;
+	supportedVersions: readonly string[];
+}
+
+/**
+ * Negotiate protocol version, create a session, and return the JSON-RPC
+ * result body. The caller (transport core) maps `ok: false` to HTTP 400.
+ *
+ * Per the MCP spec: if the client requests a version the server does not
+ * support, the server MUST respond with a version it does support (so the
+ * client can decide whether to downgrade or disconnect) — NOT fail. We
+ * pick `PROTOCOL_VERSION_PREFERRED` for any unknown version. The only
+ * `ok: false` cases are a missing or non-string `protocolVersion` field,
+ * which is a protocol-level violation rather than version negotiation.
+ *
+ * `instructions` is optional per spec; we omit it in v1 (it can be wired
+ * later when tools land in #617 and we know which profile is active).
+ */
+export async function handleInitialize(
+	params: InitializeParams | undefined,
+	user: string
+): Promise<InitializeOutcome | InitializeFailure> {
+	const requested = params?.protocolVersion;
+	if (typeof requested !== 'string') {
+		return {
+			ok: false,
+			reason: `protocolVersion is required and must be a string`,
+			supportedVersions: SUPPORTED_PROTOCOL_VERSIONS,
+		};
+	}
+	const negotiated = SUPPORTED_PROTOCOL_VERSIONS.includes(requested as (typeof SUPPORTED_PROTOCOL_VERSIONS)[number])
+		? requested
+		: PROTOCOL_VERSION_PREFERRED;
+	const session = await createSession({ user, protocolVersion: negotiated });
+	return {
+		ok: true,
+		session,
+		result: {
+			protocolVersion: negotiated,
+			serverInfo: SERVER_INFO,
+			capabilities: SERVER_CAPABILITIES,
+		},
+	};
+}
+
+/**
+ * Flip the session to `initialized: true`. Called when the client posts the
+ * `notifications/initialized` JSON-RPC notification (per MCP §lifecycle).
+ * The transport returns HTTP 202 with no body regardless of outcome here.
+ */
+export async function handleInitialized(session: McpSessionRecord): Promise<McpSessionRecord> {
+	if (session.initialized) return session;
+	const updated: McpSessionRecord = { ...session, initialized: true };
+	await saveSession(updated);
+	return updated;
+}

package/components/mcp/listChanged.ts

@@ -0,0 +1,270 @@
+/**
+ * MCP server-push notification dispatcher (#619). Subscribes to Harper's
+ * existing role-cache-invalidation + schema-reload event channels and
+ * emits per-session `notifications/tools/list_changed` /
+ * `notifications/resources/list_changed` frames over the registered
+ * SSE streams.
+ *
+ * Per-session computation only — never broadcast. For each event, we
+ * walk the per-worker session registry, re-resolve the session's user
+ * (so the diff sees the freshly-mutated permission set, not the snapshot
+ * captured at GET-stream open), recompute that session's tools/list (or
+ * resources/list) under the fresh user, diff against the snapshot from
+ * the prior emission, and push a notification iff the visible set
+ * actually changed. Sessions whose visible surface is unchanged see
+ * nothing.
+ */
+import harperLogger from '../../utility/logging/harper_logger.ts';
+import { listResources } from './resources.ts';
+import { type RegisteredSession, forEachSessionByProfile, getRegisteredSession } from './sessionRegistry.ts';
+import { listTools, type AuthedUser } from './toolRegistry.ts';
+import type { McpProfile } from './transport.ts';
+
+const MAX_TOOLS_PAGE = 1000;
+const MAX_RESOURCES_PAGE = 1000;
+
+let initialized = false;
+let onUserChangeBound: (() => void) | undefined;
+let onSchemaChangeBound: (() => void) | undefined;
+
+// Test seams: avoid importing the real ITC handler from unit tests.
+let _itcHandlersOverride:
+	| {
+			userHandler?: { addListener?: (fn: () => void) => void };
+			schemaHandler?: { addListener?: (fn: () => void) => void };
+	  }
+	| undefined;
+
+export function _setItcHandlersForTest(
+	h:
+		| {
+				userHandler?: { addListener?: (fn: () => void) => void };
+				schemaHandler?: { addListener?: (fn: () => void) => void };
+		  }
+		| undefined
+): void {
+	_itcHandlersOverride = h;
+}
+
+export function _resetListChangedForTest(): void {
+	initialized = false;
+	onUserChangeBound = undefined;
+	onSchemaChangeBound = undefined;
+}
+
+function loadItcHandlers():
+	| {
+			userHandler?: { addListener?: (fn: () => void) => void };
+			schemaHandler?: { addListener?: (fn: () => void) => void };
+	  }
+	| undefined {
+	if (_itcHandlersOverride) return _itcHandlersOverride;
+	try {
+		return require('../../server/itc/serverHandlers');
+	} catch (err) {
+		harperLogger.trace(`MCP listChanged: ITC handlers unavailable (${(err as Error).message})`);
+		return undefined;
+	}
+}
+
+// Test seam: lets unit tests stub the user re-resolution without pulling in
+// security/user.ts (which initializes the system catalogs at module-load).
+let _userResolverOverride: ((username: string) => Promise<AuthedUser | undefined>) | undefined;
+
+export function _setUserResolverForTest(fn: ((username: string) => Promise<AuthedUser | undefined>) | undefined): void {
+	_userResolverOverride = fn;
+}
+
+async function resolveUser(username: string | undefined): Promise<AuthedUser | undefined> {
+	if (!username) return undefined;
+	if (_userResolverOverride) return _userResolverOverride(username);
+	try {
+		const { findAndValidateUser } = require('../../security/user');
+		const fresh = await findAndValidateUser(username, null, false);
+		return fresh as AuthedUser;
+	} catch (err) {
+		harperLogger.trace(`MCP listChanged: user re-resolve failed for ${username}: ${(err as Error).message}`);
+		return undefined;
+	}
+}
+
+function toolsListNames(profile: McpProfile, session: RegisteredSession): Array<{ name: string }> {
+	const { tools } = listTools({
+		user: session.user,
+		profile,
+		sessionId: session.sessionId,
+		limit: MAX_TOOLS_PAGE,
+	});
+	return tools.map((t) => ({ name: t.name }));
+}
+
+function resourcesListUris(profile: McpProfile, session: RegisteredSession): Array<{ uri: string }> {
+	const result = listResources({ user: session.user, profile, limit: MAX_RESOURCES_PAGE });
+	return result.resources.map((r) => ({ uri: r.uri }));
+}
+
+function sameSet(
+	a: ReadonlyArray<{ name?: string; uri?: string }> | undefined,
+	b: ReadonlyArray<{ name?: string; uri?: string }>
+): boolean {
+	if (!a) return false;
+	if (a.length !== b.length) return false;
+	const aKeys = new Set(a.map((x) => x.name ?? x.uri));
+	for (const x of b) {
+		if (!aKeys.has(x.name ?? x.uri)) return false;
+	}
+	return true;
+}
+
+/**
+ * Re-emit `notifications/tools/list_changed` for one session iff its
+ * visible tools list has changed since the last snapshot. Wrapped in
+ * try/catch so a single failing session never breaks the loop.
+ */
+function maybeNotifyToolsChanged(record: RegisteredSession): void {
+	try {
+		const current = toolsListNames(record.profile, record);
+		if (sameSet(record.lastTools, current)) return;
+		record.lastTools = current;
+		record.queue.send({
+			event: 'message',
+			data: { jsonrpc: '2.0', method: 'notifications/tools/list_changed' },
+		});
+	} catch (err) {
+		harperLogger.trace(`MCP listChanged tools/* for session ${record.sessionId}: ${(err as Error).message}`);
+	}
+}
+
+function maybeNotifyResourcesChanged(record: RegisteredSession): void {
+	try {
+		const current = resourcesListUris(record.profile, record);
+		if (sameSet(record.lastResources, current)) return;
+		record.lastResources = current;
+		record.queue.send({
+			event: 'message',
+			data: { jsonrpc: '2.0', method: 'notifications/resources/list_changed' },
+		});
+	} catch (err) {
+		harperLogger.trace(`MCP listChanged resources/* for session ${record.sessionId}: ${(err as Error).message}`);
+	}
+}
+
+/**
+ * Snapshot the current registry as a flat list so re-resolves can happen
+ * sequentially without re-walking the live map (which a concurrent
+ * registerSession could mutate mid-iteration).
+ */
+function snapshotSessions(profile: McpProfile): RegisteredSession[] {
+	const out: RegisteredSession[] = [];
+	forEachSessionByProfile(profile, (r) => out.push(r));
+	return out;
+}
+
+async function refreshSessionUser(record: RegisteredSession): Promise<void> {
+	const fresh = await resolveUser(record.user?.username);
+	if (fresh) record.user = fresh;
+}
+
+/**
+ * Fan out a user/role change: for each session on either profile,
+ * re-resolve the user (so a role-perm mutation is visible to the diff —
+ * the captured `record.user` at GET-stream open is otherwise frozen),
+ * recompute the tools list and notify if changed. Resources may also
+ * change visibility (table-perm-gated schema URIs), so we re-check
+ * those too.
+ */
+async function onUserChange(): Promise<void> {
+	for (const r of snapshotSessions('operations')) {
+		await refreshSessionUser(r);
+		maybeNotifyToolsChanged(r);
+		maybeNotifyResourcesChanged(r);
+	}
+	for (const r of snapshotSessions('application')) {
+		await refreshSessionUser(r);
+		maybeNotifyToolsChanged(r);
+		maybeNotifyResourcesChanged(r);
+	}
+}
+
+/**
+ * Schema changes touch both surfaces — application-profile tools are
+ * generated from the Resources registry, and operations-profile
+ * resources include the OPERATION list (unchanged) plus harper://schema
+ * URIs (changed). Application sessions need the bigger refresh. We also
+ * re-resolve the user here in case the schema change coincided with a
+ * role mutation (Harper sometimes fires both channels on database-level
+ * grants).
+ */
+async function onSchemaChange(): Promise<void> {
+	for (const r of snapshotSessions('application')) {
+		await refreshSessionUser(r);
+		maybeNotifyToolsChanged(r);
+		maybeNotifyResourcesChanged(r);
+	}
+	// Operations sessions only need resources/list refresh — there are no
+	// schema-derived operations tools, but `harper://schema/...` URIs may
+	// shift if a new table appears under a database the user can describe.
+	for (const r of snapshotSessions('operations')) {
+		await refreshSessionUser(r);
+		maybeNotifyResourcesChanged(r);
+	}
+}
+
+/**
+ * Idempotent: subscribe once at component boot. Repeated calls are
+ * no-ops. Returns true if subscriptions were actually installed (false
+ * if Harper's ITC handlers aren't available in this process).
+ */
+export function initListChanged(): boolean {
+	if (initialized) return true;
+	const handlers = loadItcHandlers();
+	if (!handlers) return false;
+	let installed = 0;
+	if (handlers.userHandler?.addListener) {
+		// Harper's ITC handler treats listeners as `() => void`. Our handler is
+		// async (re-resolves users); fire-and-forget with a swallow so a rejection
+		// can never escape the event emitter as an UnhandledPromiseRejection.
+		onUserChangeBound = () => {
+			onUserChange().catch((err) => harperLogger.trace(`MCP listChanged onUserChange: ${(err as Error).message}`));
+		};
+		handlers.userHandler.addListener(onUserChangeBound);
+		installed++;
+	}
+	if (handlers.schemaHandler?.addListener) {
+		onSchemaChangeBound = () => {
+			onSchemaChange().catch((err) => harperLogger.trace(`MCP listChanged onSchemaChange: ${(err as Error).message}`));
+		};
+		handlers.schemaHandler.addListener(onSchemaChangeBound);
+		installed++;
+	}
+	initialized = installed > 0;
+	if (initialized) {
+		harperLogger.info(`MCP listChanged: subscribed to ${installed} event channel(s)`);
+	} else {
+		harperLogger.warn(
+			'MCP listChanged: ITC handlers do not expose addListener; list_changed notifications will not fire'
+		);
+	}
+	return initialized;
+}
+
+/**
+ * Compute and stash the initial tools/resources snapshot for a session
+ * that just opened its GET stream. Without this seed, the first event
+ * would always be a "changed" because `lastTools === undefined !==
+ * current`. Call right after registerSession.
+ */
+export function seedSessionSnapshot(sessionId: string): void {
+	const record = getRegisteredSession(sessionId);
+	if (!record) return;
+	try {
+		record.lastTools = toolsListNames(record.profile, record);
+	} catch (err) {
+		harperLogger.trace(`MCP seed tools list for ${sessionId}: ${(err as Error).message}`);
+	}
+	try {
+		record.lastResources = resourcesListUris(record.profile, record);
+	} catch (err) {
+		harperLogger.trace(`MCP seed resources list for ${sessionId}: ${(err as Error).message}`);
+	}
+}