@forge-glance/sdk 0.1.0

package/dist/ActionCableClient.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ActionCableClient — outgoing WebSocket client for GitLab's ActionCable endpoint.
+ *
+ * Connects to wss://{baseURL}/-/cable, implements the ActionCable protocol
+ * (subscribe/unsubscribe/ping/confirm), and auto-reconnects with exponential backoff.
+ *
+ * Mirrors Swift's ActionCableClient.swift.
+ */
+import { type ForgeLogger } from "./logger.ts";
+export interface ActionCableCallbacks {
+    onConnected(): void;
+    onDisconnected(intentional: boolean, reason: string): void;
+    onMessage(identifier: string, message: unknown): void;
+    onConfirm(identifier: string): void;
+    onReject(identifier: string): void;
+}
+export declare class ActionCableClient {
+    private readonly token;
+    private readonly callbacks;
+    private ws;
+    private reconnectAttempt;
+    private intentionalDisconnect;
+    private reconnectTimer;
+    private readonly wsUrl;
+    private readonly originUrl;
+    private readonly log;
+    private readonly logContext;
+    constructor(baseURL: string, token: string, callbacks: ActionCableCallbacks, options?: {
+        logger?: ForgeLogger;
+        logContext?: string;
+    });
+    connect(): void;
+    disconnect(): void;
+    subscribe(identifier: string): void;
+    unsubscribe(identifier: string): void;
+    private performConnect;
+    private handleMessage;
+    private send;
+    private cleanup;
+    private scheduleReconnect;
+}

package/dist/ActionCableClient.js

@@ -0,0 +1,189 @@
+// src/logger.ts
+var noopLogger = {
+  debug() {},
+  info() {},
+  warn() {},
+  error() {}
+};
+
+// src/ActionCableClient.ts
+var BASE_RECONNECT_DELAY_MS = 1000;
+var MAX_RECONNECT_DELAY_MS = 120000;
+var MAX_RECONNECT_ATTEMPTS = 8;
+
+class ActionCableClient {
+  token;
+  callbacks;
+  ws = null;
+  reconnectAttempt = 0;
+  intentionalDisconnect = false;
+  reconnectTimer = null;
+  wsUrl;
+  originUrl;
+  log;
+  logContext;
+  constructor(baseURL, token, callbacks, options = {}) {
+    this.token = token;
+    this.callbacks = callbacks;
+    this.log = options.logger ?? noopLogger;
+    this.logContext = options.logContext ?? "";
+    const stripped = baseURL.replace(/\/$/, "");
+    this.originUrl = stripped;
+    this.wsUrl = stripped.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://") + "/-/cable";
+  }
+  connect() {
+    this.intentionalDisconnect = false;
+    this.reconnectAttempt = 0;
+    this.performConnect();
+  }
+  disconnect() {
+    this.intentionalDisconnect = true;
+    this.cleanup();
+    this.log.info("ActionCable intentionally disconnected", {
+      url: this.wsUrl,
+      ctx: this.logContext
+    });
+  }
+  subscribe(identifier) {
+    this.send({ command: "subscribe", identifier });
+  }
+  unsubscribe(identifier) {
+    this.send({ command: "unsubscribe", identifier });
+  }
+  performConnect() {
+    this.cleanup();
+    let ws;
+    try {
+      ws = new WebSocket(this.wsUrl, {
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          Origin: this.originUrl
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.log.error("ActionCable failed to create WebSocket", {
+        url: this.wsUrl,
+        message,
+        ctx: this.logContext
+      });
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws = ws;
+    ws.onmessage = (event) => {
+      const raw = typeof event.data === "string" ? event.data : String(event.data);
+      this.handleMessage(raw);
+    };
+    ws.onclose = (event) => {
+      if (this.intentionalDisconnect) {
+        this.callbacks.onDisconnected(true, "intentional disconnect");
+      } else {
+        const reason = event.reason || `code ${event.code}`;
+        this.log.warn("ActionCable disconnected", {
+          url: this.wsUrl,
+          reason,
+          ctx: this.logContext
+        });
+        this.callbacks.onDisconnected(false, reason);
+        this.scheduleReconnect();
+      }
+    };
+    ws.onerror = () => {
+      this.log.warn("ActionCable WebSocket error", { url: this.wsUrl, ctx: this.logContext });
+    };
+    this.log.info("ActionCable connecting", { url: this.wsUrl, ctx: this.logContext });
+  }
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!msg.type) {
+      if (typeof msg.identifier === "string" && msg.message !== undefined) {
+        this.callbacks.onMessage(msg.identifier, msg.message);
+      }
+      return;
+    }
+    switch (msg.type) {
+      case "welcome":
+        this.reconnectAttempt = 0;
+        this.log.info("ActionCable connected (welcome)", { url: this.wsUrl, ctx: this.logContext });
+        this.callbacks.onConnected();
+        break;
+      case "ping":
+        break;
+      case "confirm_subscription":
+        if (typeof msg.identifier === "string") {
+          this.log.debug("ActionCable subscription confirmed", { ctx: this.logContext });
+          this.callbacks.onConfirm(msg.identifier);
+        }
+        break;
+      case "reject_subscription":
+        if (typeof msg.identifier === "string") {
+          this.log.warn("ActionCable subscription rejected", { ctx: this.logContext });
+          this.callbacks.onReject(msg.identifier);
+        }
+        break;
+      case "disconnect": {
+        const shouldReconnect = msg.reconnect !== false;
+        this.log.info("ActionCable server disconnect", {
+          reason: msg.reason,
+          reconnect: shouldReconnect,
+          ctx: this.logContext
+        });
+        if (!shouldReconnect)
+          this.intentionalDisconnect = true;
+        this.callbacks.onDisconnected(!shouldReconnect, msg.reason ?? "server disconnect");
+        break;
+      }
+    }
+  }
+  send(obj) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(obj));
+    }
+  }
+  cleanup() {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws !== null) {
+      this.ws.onmessage = null;
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempt >= MAX_RECONNECT_ATTEMPTS) {
+      this.log.error("ActionCable max reconnect attempts reached", {
+        url: this.wsUrl,
+        ctx: this.logContext
+      });
+      return;
+    }
+    const base = BASE_RECONNECT_DELAY_MS * Math.pow(2, this.reconnectAttempt);
+    const jitter = Math.random() * base * 0.3;
+    const delayMs = Math.min(base + jitter, MAX_RECONNECT_DELAY_MS);
+    this.reconnectAttempt++;
+    this.log.info("ActionCable scheduling reconnect", {
+      attempt: this.reconnectAttempt,
+      delayMs: Math.round(delayMs),
+      ctx: this.logContext
+    });
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (!this.intentionalDisconnect) {
+        this.performConnect();
+      }
+    }, delayMs);
+  }
+}
+export {
+  ActionCableClient
+};

package/dist/GitHubProvider.d.ts

@@ -0,0 +1,50 @@
+/**
+ * GitHub provider implementation (Phase C1 spike).
+ *
+ * Uses the GitHub REST API v3 to fetch pull requests, PR details, and
+ * discussions. Maps GitHub responses to the same provider-agnostic domain
+ * types used by GitLab, so the Swift client renders them identically.
+ *
+ * Auth: expects a GitHub Personal Access Token (classic or fine-grained)
+ * with `repo` scope. Passed as `Authorization: Bearer <token>`.
+ *
+ * Base URL: "https://api.github.com" for github.com; for GHES, the user
+ * provides the instance URL and we append "/api/v3".
+ */
+import type { GitProvider } from "./GitProvider.ts";
+import type { MRDetail, PullRequest, UserRef } from "./types.ts";
+import { type ForgeLogger } from "./logger.ts";
+export declare class GitHubProvider implements GitProvider {
+    readonly providerName: "github";
+    readonly baseURL: string;
+    private readonly apiBase;
+    private readonly token;
+    private readonly log;
+    /**
+     * @param baseURL — The user-facing GitHub URL. For github.com: "https://github.com".
+     *   For GHES: "https://github.mycompany.com".
+     * @param token — A GitHub PAT (classic or fine-grained) with `repo` scope.
+     * @param options.logger — Optional logger; defaults to noop.
+     */
+    constructor(baseURL: string, token: string, options?: {
+        logger?: ForgeLogger;
+    });
+    validateToken(): Promise<UserRef>;
+    fetchPullRequests(): Promise<PullRequest[]>;
+    fetchSingleMR(projectPath: string, mrIid: number, _currentUserNumericId: number | null): Promise<PullRequest | null>;
+    fetchMRDiscussions(repositoryId: string, mrIid: number): Promise<MRDetail>;
+    restRequest(method: string, path: string, body?: unknown): Promise<Response>;
+    private api;
+    /**
+     * Search for PRs using the GitHub search API.
+     * Returns up to 100 results per query.
+     */
+    private searchPRs;
+    private fetchReviews;
+    private fetchCheckRuns;
+    private fetchAllPages;
+    /**
+     * Convert a GitHub PR + reviews + check runs into our domain PullRequest.
+     */
+    private toPullRequest;
+}

package/dist/GitHubProvider.js

@@ -0,0 +1,361 @@
+// src/logger.ts
+var noopLogger = {
+  debug() {},
+  info() {},
+  warn() {},
+  error() {}
+};
+
+// src/GitHubProvider.ts
+function toUserRef(u) {
+  return {
+    id: `github:user:${u.id}`,
+    username: u.login,
+    name: u.name ?? u.login,
+    avatarUrl: u.avatar_url
+  };
+}
+function normalizePRState(pr) {
+  if (pr.merged_at)
+    return "merged";
+  if (pr.state === "open")
+    return "opened";
+  return "closed";
+}
+function toPipeline(checkRuns, prHtmlUrl) {
+  if (checkRuns.length === 0)
+    return null;
+  const jobs = checkRuns.map((cr) => ({
+    id: `github:check:${cr.id}`,
+    name: cr.name,
+    stage: "checks",
+    status: normalizeCheckStatus(cr),
+    allowFailure: false,
+    webUrl: cr.html_url
+  }));
+  const statuses = jobs.map((j) => j.status);
+  let overallStatus;
+  if (statuses.some((s) => s === "failed")) {
+    overallStatus = "failed";
+  } else if (statuses.some((s) => s === "running")) {
+    overallStatus = "running";
+  } else if (statuses.some((s) => s === "pending")) {
+    overallStatus = "pending";
+  } else if (statuses.every((s) => s === "success" || s === "skipped")) {
+    overallStatus = "success";
+  } else {
+    overallStatus = "pending";
+  }
+  return {
+    id: `github:checks:${prHtmlUrl}`,
+    status: overallStatus,
+    createdAt: null,
+    webUrl: `${prHtmlUrl}/checks`,
+    jobs
+  };
+}
+function normalizeCheckStatus(cr) {
+  if (cr.status === "completed") {
+    switch (cr.conclusion) {
+      case "success":
+        return "success";
+      case "failure":
+      case "timed_out":
+        return "failed";
+      case "cancelled":
+        return "canceled";
+      case "skipped":
+        return "skipped";
+      case "neutral":
+        return "success";
+      case "action_required":
+        return "manual";
+      default:
+        return "pending";
+    }
+  }
+  if (cr.status === "in_progress")
+    return "running";
+  return "pending";
+}
+
+class GitHubProvider {
+  providerName = "github";
+  baseURL;
+  apiBase;
+  token;
+  log;
+  constructor(baseURL, token, options = {}) {
+    this.baseURL = baseURL.replace(/\/$/, "");
+    this.token = token;
+    this.log = options.logger ?? noopLogger;
+    if (this.baseURL === "https://github.com" || this.baseURL === "https://www.github.com") {
+      this.apiBase = "https://api.github.com";
+    } else {
+      this.apiBase = `${this.baseURL}/api/v3`;
+    }
+  }
+  async validateToken() {
+    const res = await this.api("GET", "/user");
+    if (!res.ok) {
+      throw new Error(`GitHub token validation failed: ${res.status} ${res.statusText}`);
+    }
+    const user = await res.json();
+    return toUserRef(user);
+  }
+  async fetchPullRequests() {
+    const [authored, reviewRequested, assigned] = await Promise.all([
+      this.searchPRs("is:open is:pr author:@me"),
+      this.searchPRs("is:open is:pr review-requested:@me"),
+      this.searchPRs("is:open is:pr assignee:@me")
+    ]);
+    const byKey = new Map;
+    const roles = new Map;
+    const addAll = (prs, role) => {
+      for (const pr of prs) {
+        const key = `${pr.base.repo.id}:${pr.number}`;
+        if (!byKey.has(key)) {
+          byKey.set(key, pr);
+          roles.set(key, [role]);
+        } else {
+          const existing = roles.get(key);
+          if (!existing.includes(role))
+            existing.push(role);
+        }
+      }
+    };
+    addAll(authored, "author");
+    addAll(reviewRequested, "reviewer");
+    addAll(assigned, "assignee");
+    const entries = [...byKey.entries()];
+    const results = await Promise.all(entries.map(async ([key, pr]) => {
+      const prRoles = roles.get(key) ?? ["author"];
+      const [reviews, checkRuns] = await Promise.all([
+        this.fetchReviews(pr.base.repo.full_name, pr.number),
+        this.fetchCheckRuns(pr.base.repo.full_name, pr.head.sha)
+      ]);
+      return this.toPullRequest(pr, prRoles, reviews, checkRuns);
+    }));
+    this.log.debug("GitHubProvider.fetchPullRequests", { count: results.length });
+    return results;
+  }
+  async fetchSingleMR(projectPath, mrIid, _currentUserNumericId) {
+    try {
+      const res = await this.api("GET", `/repos/${projectPath}/pulls/${mrIid}`);
+      if (!res.ok)
+        return null;
+      const pr = await res.json();
+      const [reviews, checkRuns] = await Promise.all([
+        this.fetchReviews(projectPath, mrIid),
+        this.fetchCheckRuns(projectPath, pr.head.sha)
+      ]);
+      const currentUser = await this.api("GET", "/user");
+      const currentUserData = await currentUser.json();
+      const prRoles = [];
+      if (pr.user.id === currentUserData.id)
+        prRoles.push("author");
+      if (pr.assignees.some((a) => a.id === currentUserData.id))
+        prRoles.push("assignee");
+      if (pr.requested_reviewers.some((r) => r.id === currentUserData.id))
+        prRoles.push("reviewer");
+      return this.toPullRequest(pr, prRoles.length > 0 ? prRoles : ["author"], reviews, checkRuns);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.log.warn("GitHubProvider.fetchSingleMR failed", {
+        projectPath,
+        mrIid,
+        message
+      });
+      return null;
+    }
+  }
+  async fetchMRDiscussions(repositoryId, mrIid) {
+    const repoId = parseInt(repositoryId.split(":").pop() ?? "0", 10);
+    const repoRes = await this.api("GET", `/repositories/${repoId}`);
+    if (!repoRes.ok) {
+      throw new Error(`Failed to fetch repo: ${repoRes.status}`);
+    }
+    const repo = await repoRes.json();
+    const [reviewComments, issueComments] = await Promise.all([
+      this.fetchAllPages(`/repos/${repo.full_name}/pulls/${mrIid}/comments?per_page=100`),
+      this.fetchAllPages(`/repos/${repo.full_name}/issues/${mrIid}/comments?per_page=100`)
+    ]);
+    const discussions = [];
+    for (const c of issueComments) {
+      discussions.push({
+        id: `gh-issue-comment-${c.id}`,
+        resolvable: null,
+        resolved: null,
+        notes: [toNote(c)]
+      });
+    }
+    const threadMap = new Map;
+    for (const c of reviewComments) {
+      const rootId = c.in_reply_to_id ?? c.id;
+      const thread = threadMap.get(rootId) ?? [];
+      thread.push(c);
+      threadMap.set(rootId, thread);
+    }
+    for (const [rootId, comments] of threadMap) {
+      comments.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+      discussions.push({
+        id: `gh-review-thread-${rootId}`,
+        resolvable: true,
+        resolved: null,
+        notes: comments.map(toNote)
+      });
+    }
+    return { mrIid, repositoryId, discussions };
+  }
+  async restRequest(method, path, body) {
+    return this.api(method, path, body);
+  }
+  async api(method, path, body) {
+    const url = `${this.apiBase}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28"
+    };
+    if (body !== undefined) {
+      headers["Content-Type"] = "application/json";
+    }
+    return fetch(url, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+  }
+  async searchPRs(qualifiers) {
+    const q = encodeURIComponent(qualifiers);
+    const res = await this.api("GET", `/search/issues?q=${q}&per_page=100&sort=updated`);
+    if (!res.ok) {
+      this.log.warn("GitHub search failed", { status: res.status, qualifiers });
+      return [];
+    }
+    const data = await res.json();
+    const prPromises = data.items.filter((item) => item.pull_request).map(async (item) => {
+      const repoPath = item.repository_url.replace(`${this.apiBase}/repos/`, "");
+      const res2 = await this.api("GET", `/repos/${repoPath}/pulls/${item.number}`);
+      if (!res2.ok)
+        return null;
+      return await res2.json();
+    });
+    const results = await Promise.all(prPromises);
+    return results.filter((pr) => pr !== null);
+  }
+  async fetchReviews(repoPath, prNumber) {
+    return this.fetchAllPages(`/repos/${repoPath}/pulls/${prNumber}/reviews?per_page=100`);
+  }
+  async fetchCheckRuns(repoPath, sha) {
+    try {
+      const res = await this.api("GET", `/repos/${repoPath}/commits/${sha}/check-runs?per_page=100`);
+      if (!res.ok)
+        return [];
+      const data = await res.json();
+      return data.check_runs;
+    } catch {
+      return [];
+    }
+  }
+  async fetchAllPages(path) {
+    const results = [];
+    let url = path;
+    while (url) {
+      const res = await this.api("GET", url);
+      if (!res.ok)
+        break;
+      const items = await res.json();
+      results.push(...items);
+      const linkHeader = res.headers.get("Link");
+      const nextMatch = linkHeader?.match(/<([^>]+)>;\s*rel="next"/);
+      if (nextMatch) {
+        url = nextMatch[1].replace(this.apiBase, "");
+      } else {
+        url = null;
+      }
+    }
+    return results;
+  }
+  toPullRequest(pr, roles, reviews, checkRuns) {
+    const latestReviewByUser = new Map;
+    for (const r of reviews.sort((a, b) => new Date(a.submitted_at).getTime() - new Date(b.submitted_at).getTime())) {
+      latestReviewByUser.set(r.user.id, r);
+    }
+    const approvedBy = [];
+    let changesRequested = 0;
+    for (const r of latestReviewByUser.values()) {
+      if (r.state === "APPROVED") {
+        approvedBy.push(toUserRef(r.user));
+      } else if (r.state === "CHANGES_REQUESTED") {
+        changesRequested++;
+      }
+    }
+    const approvalsLeft = changesRequested;
+    const diffStats = pr.additions !== undefined ? {
+      additions: pr.additions,
+      deletions: pr.deletions ?? 0,
+      filesChanged: pr.changed_files ?? 0
+    } : null;
+    const conflicts = pr.mergeable === false || pr.mergeable_state === "dirty";
+    const pipeline = toPipeline(checkRuns, pr.html_url);
+    return {
+      id: `github:pr:${pr.id}`,
+      iid: pr.number,
+      repositoryId: `github:${pr.base.repo.id}`,
+      title: pr.title,
+      state: normalizePRState(pr),
+      draft: pr.draft,
+      conflicts,
+      webUrl: pr.html_url,
+      sourceBranch: pr.head.ref,
+      targetBranch: pr.base.ref,
+      createdAt: pr.created_at,
+      updatedAt: pr.updated_at,
+      sha: pr.head.sha,
+      author: toUserRef(pr.user),
+      assignees: pr.assignees.map(toUserRef),
+      reviewers: pr.requested_reviewers.map(toUserRef),
+      roles,
+      pipeline,
+      description: pr.body ?? null,
+      unresolvedThreadCount: 0,
+      approvalsLeft,
+      approved: approvedBy.length > 0 && changesRequested === 0,
+      approvedBy,
+      diffStats,
+      detailedMergeStatus: null
+    };
+  }
+}
+function toNote(c) {
+  const position = c.path ? {
+    newPath: c.path,
+    oldPath: c.path,
+    newLine: c.line ?? null,
+    oldLine: c.original_line ?? null,
+    positionType: c.path ? "text" : null
+  } : null;
+  return {
+    id: c.id,
+    body: c.body,
+    author: toNoteAuthor(c.user),
+    createdAt: c.created_at,
+    system: false,
+    type: c.path ? "DiffNote" : "DiscussionNote",
+    resolvable: c.path ? true : null,
+    resolved: null,
+    position
+  };
+}
+function toNoteAuthor(u) {
+  return {
+    id: `github:user:${u.id}`,
+    username: u.login,
+    name: u.name ?? u.login,
+    avatarUrl: u.avatar_url
+  };
+}
+export {
+  GitHubProvider
+};

package/dist/GitLabProvider.d.ts

@@ -0,0 +1,34 @@
+import type { GitProvider } from "./GitProvider.ts";
+import type { MRDetail, PullRequest, UserRef } from "./types.ts";
+import { type ForgeLogger } from "./logger.ts";
+/**
+ * Strips the provider prefix from a scoped repositoryId and returns the
+ * numeric GitLab project ID needed for REST API calls.
+ * e.g. "gitlab:42" → 42
+ */
+export declare function parseGitLabRepoId(repositoryId: string): number;
+export declare const MR_DASHBOARD_FRAGMENT = "\n  fragment MRDashboardFields on MergeRequest {\n    id iid projectId title description state draft\n    sourceBranch targetBranch webUrl\n    diffHeadSha\n    updatedAt createdAt\n    conflicts\n    detailedMergeStatus\n    approved\n    diffStatsSummary { additions deletions fileCount }\n    author { id username name avatarUrl }\n    assignees(first: 20) { nodes { id username name avatarUrl } }\n    reviewers(first: 20) { nodes { id username name avatarUrl } }\n    approvedBy(first: 20) { nodes { id username name avatarUrl } }\n    approvalsLeft\n    resolvableDiscussionsCount\n    resolvedDiscussionsCount\n    headPipeline {\n      id iid status\n      createdAt\n      path\n      stages(first: 20) { nodes {\n        name\n        jobs(first: 50) { nodes {\n          id name status\n          allowFailure\n          webPath\n          stage { name }\n        }}\n      }}\n    }\n  }\n";
+export declare class GitLabProvider implements GitProvider {
+    readonly providerName: "gitlab";
+    readonly baseURL: string;
+    private readonly token;
+    private readonly log;
+    private readonly mrDetailFetcher;
+    constructor(baseURL: string, token: string, options?: {
+        logger?: ForgeLogger;
+    });
+    validateToken(): Promise<UserRef>;
+    /**
+     * Fetch a single MR by project path and IID.
+     * Used by SubscriptionManager when `userMergeRequestUpdated` fires.
+     * Returns null if the project or MR doesn't exist.
+     *
+     * Roles are computed by matching `currentUserNumericId` against the MR's
+     * author, assignees, and reviewers.
+     */
+    fetchSingleMR(projectPath: string, mrIid: number, currentUserNumericId: number | null): Promise<PullRequest | null>;
+    fetchPullRequests(): Promise<PullRequest[]>;
+    fetchMRDiscussions(repositoryId: string, mrIid: number): Promise<MRDetail>;
+    restRequest(method: string, path: string, body?: unknown): Promise<Response>;
+    private runQuery;
+}