@oar-sh/oar 0.9.0

package/server/public/app/relay-dot-state.mjs

@@ -0,0 +1,69 @@
+/**
+ * Resolves the relay status dot's colour and tooltip.
+ *
+ * The dot's primary meaning is unchanged: grey when the web relay is
+ * unreachable, coloured when it answers. Cloudflare Tunnel mode adds a third
+ * colour so it is obvious at a glance that the relay is reachable from the
+ * internet rather than only from this machine.
+ *
+ * A managed-but-disconnected tunnel stays green rather than going grey: the
+ * relay itself is still reachable, and grey would claim otherwise. The tooltip
+ * carries the bad news instead. Note this state is only ever visible locally —
+ * a remote browser whose tunnel is down cannot load the page at all.
+ *
+ * `tone` is the same state as `className`, minus the dot's CSS baggage. The
+ * mobile burger toggle dyes its bars from it, because the dot itself sits in
+ * the off-canvas sidebar and is invisible whenever the conversation list is
+ * closed. Both indicators read the one tone so they cannot disagree.
+ */
+
+function normalizeTunnel(tunnel) {
+  if (!tunnel || typeof tunnel !== 'object') return null;
+  const mode = String(tunnel.mode || '').trim().toLowerCase();
+  const managed = mode === 'managed' || tunnel.enabled === true;
+  if (!managed) return null;
+  return {
+    connected: tunnel.connected === true,
+    lastError: String(tunnel.lastError || '').trim(),
+  };
+}
+
+function describeWorkers({ processingCount = 0, errorCount = 0, questionCount = 0 } = {}) {
+  const plural = (count) => (count === 1 ? '' : 's');
+  if (processingCount > 0) return `${processingCount} session worker${plural(processingCount)} processing`;
+  if (errorCount > 0) return `${errorCount} session worker${plural(errorCount)} degraded`;
+  if (questionCount > 0) return `${questionCount} session worker${plural(questionCount)} waiting on a question`;
+  return '';
+}
+
+export function resolveRelayDotState({
+  relayOnline = false,
+  cliOnline = false,
+  cloudflaredTunnel = null,
+  processingCount = 0,
+  errorCount = 0,
+  questionCount = 0,
+} = {}) {
+  if (!relayOnline) {
+    return { className: 'offline', tone: 'offline', title: 'Web relay unreachable' };
+  }
+
+  const tunnel = normalizeTunnel(cloudflaredTunnel);
+  const tunnelled = !!tunnel && tunnel.connected;
+  const tone = tunnelled ? 'tunnelled' : 'online';
+  const className = tunnelled ? 'online tunnelled' : 'online';
+
+  let reach = 'Web relay reachable';
+  if (tunnelled) {
+    reach = 'Web relay reachable via Cloudflare Tunnel';
+  } else if (tunnel) {
+    reach = tunnel.lastError
+      ? `Web relay reachable; Cloudflare tunnel disconnected (${tunnel.lastError})`
+      : 'Web relay reachable; Cloudflare tunnel disconnected';
+  }
+
+  if (!cliOnline) return { className, tone, title: `${reach}; CLI offline` };
+
+  const workers = describeWorkers({ processingCount, errorCount, questionCount });
+  return { className, tone, title: workers ? `${reach}; ${workers}` : reach };
+}

package/server/public/app/relay-error-ctas.mjs

@@ -0,0 +1,52 @@
+// Turns a terminal turn failure in the transcript into a button that fixes it.
+//
+// `buildTerminalFailureTextForChat()` (messages-routes.mjs) renders every
+// terminal failure as plain chat text ending in `Error code: relay.<code>.`,
+// so the code is the only stable handle a client has. The dead end this exists
+// for: a Grok turn fails with relay.grok-cli-missing and the printed advice is
+// "install it on the relay host" — i.e. open a shell, the exact thing the relay
+// exists to avoid.
+//
+// Pure and DOM-free on purpose: the table is the contract, the caller owns the
+// markup and the escaping.
+
+// Codes are matched post-normalisation: normalizeTerminalErrorCode() lowercases
+// and rewrites every non-alphanumeric run to a dash, so `grok.cli_missing`
+// reaches the transcript as `relay.grok-cli-missing`.
+const RELAY_ERROR_CTAS = Object.freeze({
+  'grok-cli-missing': Object.freeze([
+    Object.freeze({ action: 'install-grok-cli', label: 'Install Grok CLI' }),
+    Object.freeze({ action: 'open-grok-settings', label: 'Grok settings' }),
+  ]),
+  'grok-authentication-failed': Object.freeze([
+    Object.freeze({ action: 'sign-in-to-grok', label: 'Sign in to Grok' }),
+    Object.freeze({ action: 'open-grok-settings', label: 'Grok settings' }),
+  ]),
+  // Shipped with the Claude relogin plan (§4.3 there) as the deep link its
+  // reworded message points at.
+  'claude-authentication-failed': Object.freeze([
+    Object.freeze({ action: 'open-claude-settings', label: 'Claude settings' }),
+  ]),
+});
+
+const STABLE_CODE_PATTERN = /error code:\s*relay\.([a-z0-9-]+)/i;
+
+export function relayErrorCodeFromText(text) {
+  const match = String(text || '').match(STABLE_CODE_PATTERN);
+  return match ? match[1].toLowerCase() : '';
+}
+
+/**
+ * The actions a terminal failure offers, or an empty array. Never throws and
+ * never guesses: an unknown code simply has no CTA, which is the current
+ * behaviour for every failure that is not in the table.
+ */
+export function relayErrorCtaActions(text) {
+  const code = relayErrorCodeFromText(text);
+  return code && RELAY_ERROR_CTAS[code] ? RELAY_ERROR_CTAS[code] : [];
+}
+
+export function relayErrorCtaActionsForCode(code) {
+  const normalized = String(code || '').trim().toLowerCase().replace(/^relay\./, '');
+  return RELAY_ERROR_CTAS[normalized] || [];
+}

package/server/public/app/relay-prompt-sanitizer.mjs

@@ -0,0 +1,114 @@
+const RELAY_TOOL_GUIDANCE = [
+  '# Relay Tool Guidance',
+  'For any user-facing question or clarification, use the ask_user tool so the web relay can render question cards and buttons. Never ask questions in plain assistant text.',
+  'When using ask_user, ALWAYS include a `choices` array with 2-6 answer options so the web relay can render clickable buttons. Only omit choices when the question genuinely requires freeform text input.',
+  'In autopilot, still call ask_user when user input is truly blocking, because the relay bridge can surface the question even when the direct SDK question hook is bypassed.',
+  'For relay restarts in extension-managed mode, require explicit user permission first, then use the authenticated localhost API `POST /api/relay/shutdown`. Do not restart by killing processes or using respawn scripts.',
+  'Note: shutdown is queued and only completes when the current turn finishes, so it is pointless to wait for it to interrupt an active turn.',
+  'Use `restart: true` in the request body when the user wants a real relay restart rather than a plain shutdown. Example request body: `{ "reason": "manual-restart", "requestedBy": "localhost-api", "restart": true }`.',
+].join(' ');
+
+const MODE_MARKERS = {
+  plan: '[Relay mode: plan]',
+  ask: '[Relay mode: ask]',
+  autopilot: '[Relay mode: autopilot]',
+  agent: '[Relay mode: agent]',
+};
+
+const MODE_INSTRUCTIONS = {
+  plan: [
+    'Draft a concise plan only.',
+    'Use read-only inspection tools (glob, rg, view) only when they materially improve plan quality; otherwise draft from provided context.',
+    'Do not edit repository files or run mutating commands unless the user explicitly asks for implementation.',
+    'If clarification is required, pause and ask through the web relay.',
+    'These instructions remain in effect until relay mode changes.',
+  ].join(' '),
+  ask: [
+    'Prioritize clarification questions before doing any implementation work.',
+    'If the request is ambiguous or underspecified, pause and ask through the web relay before making assumptions.',
+    'Do not make broad assumptions when a question would materially change the result.',
+    'These instructions remain in effect until relay mode changes.',
+  ].join(' '),
+  autopilot: [
+    'Act directly on the request and use tools when needed.',
+    'Keep moving unless user input is truly blocking.',
+    'These instructions remain in effect until relay mode changes.',
+  ].join(' '),
+  agent: [
+    'Proceed as an interactive coding agent and use tools as needed.',
+    'If you need clarification, pause and ask through the web relay instead of stalling silently.',
+    'These instructions remain in effect until relay mode changes.',
+  ].join(' '),
+};
+
+const LEGACY_MODE_INSTRUCTIONS = {
+  plan: [
+    'Draft a concise plan only.',
+    'Do not edit files or run tools unless the user explicitly asks for implementation.',
+    'If clarification is required, pause and ask through the web relay.',
+  ].join(' '),
+  ask: [
+    'Prioritize clarification questions before doing any implementation work.',
+    'If the request is ambiguous or underspecified, pause and ask through the web relay before making assumptions.',
+    'Do not make broad assumptions when a question would materially change the result.',
+  ].join(' '),
+  autopilot: [
+    'Act directly on the request and use tools when needed.',
+    'Keep moving unless user input is truly blocking.',
+  ].join(' '),
+  agent: [
+    'Proceed as an interactive coding agent and use tools as needed.',
+    'If you need clarification, pause and ask through the web relay instead of stalling silently.',
+  ].join(' '),
+};
+
+function escapeRegExp(value) {
+  return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function whitespaceFlexiblePattern(value) {
+  return String(value || '')
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((part) => escapeRegExp(part))
+    .join('\\s+');
+}
+
+function buildPromptPrefixPatterns(mode) {
+  const requestedMode = String(mode || '').trim().toLowerCase();
+  const modes = requestedMode && MODE_MARKERS[requestedMode]
+    ? [requestedMode]
+    : Object.keys(MODE_MARKERS);
+  return modes.flatMap((key) => {
+    const marker = MODE_MARKERS[key];
+    const currentFullPrefix = `${marker} ${MODE_INSTRUCTIONS[key]} ${RELAY_TOOL_GUIDANCE}`;
+    const legacyFullPrefix = `${marker} ${LEGACY_MODE_INSTRUCTIONS[key]} ${RELAY_TOOL_GUIDANCE}`;
+    return [
+      new RegExp(`^${whitespaceFlexiblePattern(currentFullPrefix)}\\s*`, 'i'),
+      new RegExp(`^${whitespaceFlexiblePattern(legacyFullPrefix)}\\s*`, 'i'),
+      new RegExp(`^${whitespaceFlexiblePattern(marker)}\\s*`, 'i'),
+    ];
+  });
+}
+
+function stripAttachmentPromptArtifacts(text) {
+  return String(text || '')
+    .replace(/<current_datetime>[\s\S]*?<\/current_datetime>/gi, '')
+    .replace(/<system_reminder>[\s\S]*?<\/system_reminder>/gi, '')
+    .replace(/\[Attached file references\][\s\S]*?\[\/Attached file references\]/gi, '')
+    .replace(/\[Attached image(?:s)?\s*:[\s\S]*?\]/gi, '')
+    .replace(/\[Attached file\s*:[\s\S]*?\]/gi, '')
+    .trim();
+}
+
+export function stripRelayPromptContext(text, relayMode = '') {
+  const value = stripAttachmentPromptArtifacts(text);
+  if (!value) return '';
+  const patterns = buildPromptPrefixPatterns(relayMode);
+  for (const pattern of patterns) {
+    const stripped = value.replace(pattern, '').trim();
+    if (stripped && stripped !== value) return stripped;
+  }
+  return value;
+}

package/server/public/app/relay-thoughts.mjs

@@ -0,0 +1,98 @@
+function normalizeSeq(value) {
+  const num = Number(value);
+  if (!Number.isFinite(num)) return null;
+  return Math.max(0, Math.trunc(num));
+}
+
+function normalizeTimestampMs(value) {
+  const text = String(value || '').trim();
+  if (!text) return null;
+  const parsed = Date.parse(text);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function toThoughtEntry(value, order) {
+  const text = String(value?.text || '');
+  if (!text.trim()) return null;
+  const reasoningId = String(value?.reasoningId || '').trim() || null;
+  const timestamp = String(value?.timestamp || '').trim() || null;
+  const subagentRunId = String(value?.subagentRunId || '').trim() || null;
+  return {
+    reasoningId,
+    seq: normalizeSeq(value?.seq),
+    text,
+    done: !!value?.done,
+    timestamp,
+    subagentRunId,
+    _order: order,
+    _timestampMs: normalizeTimestampMs(timestamp),
+  };
+}
+
+function isCandidateNewer(next, prev) {
+  if (!prev) return true;
+  if (!next) return false;
+  if (Number.isFinite(next.seq) && Number.isFinite(prev.seq) && next.seq !== prev.seq) {
+    return next.seq > prev.seq;
+  }
+  if (Number.isFinite(next._timestampMs) && Number.isFinite(prev._timestampMs) && next._timestampMs !== prev._timestampMs) {
+    return next._timestampMs > prev._timestampMs;
+  }
+  if (next.text.length !== prev.text.length) {
+    return next.text.length > prev.text.length;
+  }
+  return next._order > prev._order;
+}
+
+function sortThoughtEntries(a, b) {
+  if (Number.isFinite(a.seq) && Number.isFinite(b.seq) && a.seq !== b.seq) {
+    return a.seq - b.seq;
+  }
+  if (Number.isFinite(a._timestampMs) && Number.isFinite(b._timestampMs) && a._timestampMs !== b._timestampMs) {
+    return a._timestampMs - b._timestampMs;
+  }
+  return a._order - b._order;
+}
+
+function toArray(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  if (value instanceof Map) return Array.from(value.values());
+  return [];
+}
+
+export function normalizeRelayThoughtList(thoughts = []) {
+  const normalized = toArray(thoughts)
+    .map((entry, index) => toThoughtEntry(entry, index))
+    .filter(Boolean);
+
+  const byReasoningId = new Map();
+  const passthrough = [];
+  for (const entry of normalized) {
+    if (!entry.reasoningId) {
+      passthrough.push(entry);
+      continue;
+    }
+    const existing = byReasoningId.get(entry.reasoningId);
+    if (!existing || isCandidateNewer(entry, existing)) {
+      byReasoningId.set(entry.reasoningId, entry);
+    }
+  }
+
+  const ordered = [...byReasoningId.values(), ...passthrough].sort(sortThoughtEntries);
+  return ordered.map((entry) => ({
+    reasoningId: entry.reasoningId,
+    seq: Number.isFinite(entry.seq) ? entry.seq : null,
+    text: entry.text,
+    done: !!entry.done,
+    timestamp: entry.timestamp || null,
+    subagentRunId: entry.subagentRunId || null,
+  }));
+}
+
+export function mergeRelayThoughts(persistedThoughts = [], cachedThoughts = []) {
+  return normalizeRelayThoughtList([
+    ...toArray(persistedThoughts),
+    ...toArray(cachedThoughts),
+  ]);
+}

package/server/public/app/relay-watchdog-policy.mjs

@@ -0,0 +1,29 @@
+// Escalation policy for the relay connection watchdog. ensureSocketConnected()
+// only ever calls socket.connect(), which socket.io silently ignores while the
+// manager believes a reconnect cycle is in flight (`_reconnecting`) or the
+// socket still claims to be connected. Both states can outlive an Android
+// freeze whose timers were dropped, leaving connect() a permanent no-op. The
+// watchdog therefore counts consecutive ticks spent disconnected and, past a
+// threshold, escalates to a hard reset that rebuilds the manager state machine.
+
+// Four 5s ticks ≈ 20s. A healthy manager mid-backoff completes a full retry
+// cycle inside that window (10s max delay + 10s connect timeout only overlaps
+// when the network is genuinely down, where a reset is harmless churn), so a
+// hard reset this late only fires on wedged or dead-network states.
+export const RELAY_WATCHDOG_HARD_RESET_TICKS = 4;
+
+/**
+ * Decide what this watchdog tick should do.
+ * @param {{ state: 'connected'|'retrying'|'forced'|'disabled', disconnectedTicks: number, hardResetTicks?: number }} input
+ * @returns {{ disconnectedTicks: number, hardReset: boolean }}
+ */
+export function adviseWatchdogTick({ state, disconnectedTicks, hardResetTicks = RELAY_WATCHDOG_HARD_RESET_TICKS }) {
+  if (state === 'connected' || state === 'disabled') {
+    return { disconnectedTicks: 0, hardReset: false };
+  }
+  const next = (Number(disconnectedTicks) || 0) + 1;
+  if (next >= hardResetTicks) {
+    return { disconnectedTicks: 0, hardReset: true };
+  }
+  return { disconnectedTicks: next, hardReset: false };
+}

package/server/public/app/repo-browser-preferences.mjs

@@ -0,0 +1,79 @@
+// Browser-persisted repo browser toolbar filters.
+//
+// Kept in its own module (rather than inline in store.js) so it stays free of
+// `window`/`document` at module scope and can be unit-tested under plain node.
+// Storage is reached only inside the functions, via an injectable accessor.
+
+export const REPO_BROWSER_WORKSPACE_HIDDEN_STORAGE_KEY = 'copilot_repo_browser_hidden_workspace';
+export const REPO_BROWSER_DRIVES_HIDDEN_STORAGE_KEY = 'copilot_repo_browser_hidden_drives';
+export const REPO_BROWSER_WORKSPACE_HEAVY_STORAGE_KEY = 'copilot_repo_browser_heavy_workspace';
+
+const TRUE_VALUES = new Set(['1', 'true', 'on', 'yes']);
+const FALSE_VALUES = new Set(['0', 'false', 'off', 'no', '']);
+
+function defaultStorage() {
+  try {
+    return globalThis.localStorage || null;
+  } catch {
+    // Storage access throws outright in some privacy modes.
+    return null;
+  }
+}
+
+export function normalizeStoredBooleanFlag(rawValue, fallback = false) {
+  if (rawValue === null || rawValue === undefined) return fallback;
+  const text = String(rawValue).trim().toLowerCase();
+  if (TRUE_VALUES.has(text)) return true;
+  if (FALSE_VALUES.has(text)) return false;
+  return fallback;
+}
+
+export function readStoredBooleanFlag(key, { fallback = false, storage = defaultStorage() } = {}) {
+  if (!storage) return fallback;
+  try {
+    return normalizeStoredBooleanFlag(storage.getItem(key), fallback);
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeStoredBooleanFlag(key, value, { storage = defaultStorage() } = {}) {
+  if (!storage) return false;
+  try {
+    storage.setItem(key, value ? '1' : '0');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Every filter defaults to off, so a fresh browser profile behaves exactly as
+ * the pre-persistence build did.
+ */
+export function readRepoBrowserPreferences(storage = defaultStorage()) {
+  return {
+    workspaceIncludeHidden: readStoredBooleanFlag(REPO_BROWSER_WORKSPACE_HIDDEN_STORAGE_KEY, { storage }),
+    drivesIncludeHidden: readStoredBooleanFlag(REPO_BROWSER_DRIVES_HIDDEN_STORAGE_KEY, { storage }),
+    workspaceIncludeHeavy: readStoredBooleanFlag(REPO_BROWSER_WORKSPACE_HEAVY_STORAGE_KEY, { storage }),
+  };
+}
+
+/**
+ * The workspace root and the drives/session roots keep independent hidden-file
+ * flags in state (the toolbar even labels them differently: "Hidden" vs
+ * "Hidden/System"), so they persist under separate keys.
+ */
+export function repoBrowserHiddenStorageKeyForRoot(activeRoot) {
+  return String(activeRoot || '').trim().toLowerCase() === 'workspace'
+    ? REPO_BROWSER_WORKSPACE_HIDDEN_STORAGE_KEY
+    : REPO_BROWSER_DRIVES_HIDDEN_STORAGE_KEY;
+}
+
+export function writeRepoBrowserHiddenPreference(activeRoot, value, storage = defaultStorage()) {
+  return writeStoredBooleanFlag(repoBrowserHiddenStorageKeyForRoot(activeRoot), value, { storage });
+}
+
+export function writeRepoBrowserHeavyPreference(value, storage = defaultStorage()) {
+  return writeStoredBooleanFlag(REPO_BROWSER_WORKSPACE_HEAVY_STORAGE_KEY, value, { storage });
+}

package/server/public/app/repo-browser-tree-state.mjs

@@ -0,0 +1,97 @@
+// Pure helpers for keeping the repo browser's tree expansion alive across a
+// refetch (hidden/heavy toggle, Refresh button).
+//
+// The tree the server returns is lazy: `/api/repo/tree` ships the root plus its
+// direct children only, every dir child marked `lazy: true, childrenLoaded:
+// false`. So restoring expansion is not just a matter of keeping the
+// `expandedPaths` Set — each still-open branch has to be re-fetched, parent
+// first, before it can render as anything other than "Expand to load entries…".
+
+export const REPO_REHYDRATE_MAX_PATHS = 24;
+
+/**
+ * Root-first ancestor chain for a repo browser path, always including the
+ * synthetic root `''` and the path itself.
+ *
+ *   ''            -> ['']
+ *   'a/b/c'       -> ['', 'a', 'a/b', 'a/b/c']
+ *   '/home/s/x'   -> ['', '/', '/home', '/home/s', '/home/s/x']
+ *   'C:/Users/x'  -> ['', 'C:', 'C:/Users', 'C:/Users/x']
+ *
+ * Windows drive paths fall out of the relative branch unchanged — they are not
+ * special-cased, matching the walks this replaces.
+ */
+export function repoAncestorPaths(pathValue) {
+  const value = String(pathValue ?? '').trim();
+  if (!value) return [''];
+  const absolute = value.startsWith('/');
+  const chain = absolute ? ['', '/'] : [''];
+  if (value === '/') return chain;
+  const parts = value.split('/').filter(Boolean);
+  let rolling = '';
+  for (const part of parts) {
+    rolling = rolling ? `${rolling}/${part}` : (absolute ? `/${part}` : part);
+    chain.push(rolling);
+  }
+  return chain;
+}
+
+/**
+ * Deepest ancestor of `pathValue` (inclusive) that still resolves to a
+ * directory, falling back to `''` when the whole branch is gone. This is what
+ * makes turning hidden files back off safe: the dotfile directory the user was
+ * sitting in simply vanishes from the refetched tree.
+ */
+export function deepestExistingAncestor(pathValue, hasDirPath) {
+  const chain = repoAncestorPaths(pathValue);
+  for (let index = chain.length - 1; index >= 0; index -= 1) {
+    const candidate = chain[index];
+    if (candidate === '') return '';
+    if (typeof hasDirPath === 'function' && hasDirPath(candidate)) return candidate;
+  }
+  return '';
+}
+
+/**
+ * Ordered list of directories to re-fetch after a refresh, parents always
+ * before children (the caller walks it sequentially — `ensureRepoChildrenLoaded`
+ * rebuilds `nodeMap` on each success, and a child is only reachable once its
+ * parent's children have landed).
+ *
+ * Tier 1 — the current path's ancestor chain — is never capped: it is the
+ * correctness fix and is bounded by directory depth anyway. Tier 2 — other
+ * previously-expanded branches — is capped, and an expanded path whose parent
+ * did not make the plan is dropped along with its descendants. That is exact
+ * rather than heuristic: `renderRepoTreeNode` only descends into loaded
+ * `children`, so such a node renders the lazy placeholder no matter what
+ * `expandedPaths` says. Overflow degrades to today's behaviour (placeholder,
+ * one click to load), never to breakage.
+ */
+export function planRepoRehydration({
+  currentPath = '',
+  expandedPaths = [],
+  maxPaths = REPO_REHYDRATE_MAX_PATHS,
+} = {}) {
+  const plan = repoAncestorPaths(currentPath);
+  const planned = new Set(plan);
+
+  const candidates = [...new Set(
+    (Array.isArray(expandedPaths) ? expandedPaths : [...expandedPaths])
+      .map((value) => String(value ?? '').trim())
+      .filter((value) => !!value && !planned.has(value)),
+  )];
+  candidates.sort((left, right) => {
+    const depthDelta = repoAncestorPaths(left).length - repoAncestorPaths(right).length;
+    return depthDelta !== 0 ? depthDelta : left.localeCompare(right);
+  });
+
+  for (const candidate of candidates) {
+    if (plan.length >= maxPaths) break;
+    const chain = repoAncestorPaths(candidate);
+    const parent = chain.length >= 2 ? chain[chain.length - 2] : '';
+    if (!planned.has(parent)) continue;
+    plan.push(candidate);
+    planned.add(candidate);
+  }
+  return plan;
+}