plugin-cluster-manager 1.1.10 → 1.1.13

package/src/server/queue-scanner.ts

@@ -0,0 +1,154 @@
+/**
+ * QueueScanner — discovers all registered queues in the system.
+ *
+ * Two sources:
+ *   1. EventQueue events (registered via app.eventQueue.subscribe)
+ *   2. Redis List-based queues (convention *:plugin-*:queue)
+ *
+ * Used by the Queue Assignment UI to let admins map queues to worker stacks.
+ */
+
+import type { Application } from '@nocobase/server';
+import { getRedisClient } from './utils/redis';
+
+export type QueueItem = {
+  name: string;
+  label: string;
+  description: string;
+  type: 'event-queue' | 'redis-list';
+  pending: number | null;
+};
+
+const KNOWN_QUEUE_LABELS: Record<string, { label: string; description: string }> = {
+  'workflow:process': {
+    label: 'Workflow',
+    description: 'Process workflow executions (plugin-workflow)',
+  },
+  'async-task:process': {
+    label: 'Async Tasks',
+    description: 'Execute async tasks (plugin-async-task-manager)',
+  },
+  'knowledge-base:document-vectorize': {
+    label: 'Document Vectorization',
+    description: 'Vectorize knowledge base documents (plugin-knowledge-base)',
+  },
+  'git-review:process': {
+    label: 'Git Review',
+    description: 'AI code review jobs (plugin-git-manager)',
+  },
+  'build-guide:process': {
+    label: 'Build Guide',
+    description: 'Build user guide pages (plugin-build-guide-block)',
+  },
+  'build-ui-template:process': {
+    label: 'Build UI Template',
+    description: 'Build UI template pages (plugin-build-ui-template)',
+  },
+};
+
+/** Redis key patterns for List-based queues (same as event-queue-monitor.ts) */
+const REDIS_QUEUE_PATTERNS = ['*:plugin-git-manager:review:queue', '*:plugin-build-guide-block:build:queue'];
+
+function describeRedisQueueKey(key: string): { label: string; description: string } {
+  const parts = String(key).split(':');
+  const plugin = parts[parts.length - 3] || 'unknown';
+  const queue = parts[parts.length - 2] || key;
+  return {
+    label: `${queue} (${plugin})`,
+    description: `Redis List queue from ${plugin}`,
+  };
+}
+
+/**
+ * Discover all queues from EventQueue subscribers.
+ */
+function scanEventQueue(app: Application): QueueItem[] {
+  const eq = (app as any).eventQueue;
+  if (!eq || !eq.events) return [];
+
+  const events: Map<string, { concurrency?: number; interval?: number; shared?: boolean }> = eq.events;
+  const items: QueueItem[] = [];
+
+  for (const [channel] of events.entries()) {
+    const known = KNOWN_QUEUE_LABELS[channel];
+    items.push({
+      name: channel,
+      label: known?.label ?? channel,
+      description: known?.description ?? `EventQueue channel: ${channel}`,
+      type: 'event-queue',
+      pending: null,
+    });
+  }
+
+  return items;
+}
+
+/**
+ * Discover Redis List-based queues via SCAN.
+ */
+async function scanRedisQueues(app: Application): Promise<QueueItem[]> {
+  const redis = getRedisClient(app);
+  if (!redis) {
+    return [];
+  }
+
+  const seen = new Set<string>();
+  const items: QueueItem[] = [];
+
+  for (const pattern of REDIS_QUEUE_PATTERNS) {
+    try {
+      const keys: string[] = await redis.sendCommand(['SCAN', '0', 'MATCH', pattern, 'COUNT', '200']);
+      const keyList: string[] = typeof keys[1]?.length === 'number' ? keys[1] : [];
+
+      for (const key of keyList) {
+        if (seen.has(key)) continue;
+        seen.add(key);
+
+        const desc = describeRedisQueueKey(key);
+        let pending = 0;
+        try {
+          pending = Number(await redis.sendCommand(['LLEN', key])) || 0;
+        } catch {
+          pending = 0;
+        }
+
+        items.push({
+          name: key,
+          label: desc.label,
+          description: desc.description,
+          type: 'redis-list',
+          pending,
+        });
+      }
+    } catch {
+      // SCAN not supported or permission denied
+    }
+  }
+
+  return items;
+}
+
+/**
+ * Full queue scan — merges EventQueue + Redis results.
+ */
+export async function scanQueues(app: Application): Promise<{ queues: QueueItem[]; total: number }> {
+  const eventQueues = scanEventQueue(app);
+  const redisQueues = await scanRedisQueues(app);
+
+  // Deduplicate: if a queue name appears in both sources, prefer EventQueue
+  const seenNames = new Set<string>();
+  const merged: QueueItem[] = [];
+
+  for (const q of eventQueues) {
+    merged.push(q);
+    seenNames.add(q.name);
+  }
+  for (const q of redisQueues) {
+    if (!seenNames.has(q.name)) {
+      merged.push(q);
+      seenNames.add(q.name);
+    }
+  }
+
+  return { queues: merged, total: merged.length };
+}

package/src/server/utils/node.ts

@@ -1,5 +1,53 @@
 import os from 'os';
 
+export type NodeRole = 'app' | 'worker' | 'sandbox';
+
+/**
+ * Determine whether a WORKER_MODE value denotes a queue-processing worker
+ * (i.e. a node that does NOT serve HTTP), following NocoBase v2.1.x semantics:
+ *   ''            → app node (serves HTTP + every queue)
+ *   '!'           → app node (serves HTTP only)
+ *   '*'           → worker (serves all queues, no HTTP)
+ *   'a:b,c:d'     → worker (serves the listed queue topics, no HTTP)
+ *   '-'           → transient subprocess (not a long-lived worker)
+ * Legacy literals 'worker' / 'task' are still tolerated for older deployments.
+ * A combined value containing '!' (e.g. '!,workflow:process') still serves
+ * HTTP, so it is treated as an app node.
+ */
+export function isWorkerMode(workerMode?: string): boolean {
+  const mode = (workerMode ?? process.env.WORKER_MODE ?? '').trim();
+  if (!mode || mode === 'main' || mode === 'app') return false;
+  if (mode === '-') return false;
+  const topics = mode
+    .split(',')
+    .map((t) => t.trim())
+    .filter(Boolean);
+  if (topics.includes('!')) return false;
+  return true;
+}
+
+/**
+ * Resolve a node role from its descriptor. APP_ROLE (explicit) wins, then an
+ * explicit sandbox flag, then WORKER_MODE parsing. Works for both the local
+ * process (pass process.env values) and remote node records read from Redis.
+ */
+export function getNodeRoleFrom(opts: { workerMode?: string; appRole?: string; isSandbox?: boolean }): NodeRole {
+  if (opts.appRole === 'app' || opts.appRole === 'worker' || opts.appRole === 'sandbox') {
+    return opts.appRole;
+  }
+  if (opts.isSandbox) return 'sandbox';
+  return isWorkerMode(opts.workerMode) ? 'worker' : 'app';
+}
+
+/** Resolve the role of the current Node.js process from its environment. */
+export function getLocalRole(): NodeRole {
+  return getNodeRoleFrom({
+    workerMode: process.env.WORKER_MODE,
+    appRole: process.env.APP_ROLE,
+    isSandbox: process.env.SKILL_HUB_SANDBOX === 'true',
+  });
+}
+
 /**
  * Generate a universally unique identifier for this specific Node.js process.
  * Combines app name, worker mode, hostname, port, and PID to ensure uniqueness

package/src/server/utils/versionManager.ts

@@ -0,0 +1,69 @@
+import { getRedisClient } from './redis';
+
+const localCounters = new Map<string, number>();
+
+async function getVersion(app: any, key: string): Promise<number> {
+  const redis = getRedisClient(app);
+  if (redis) {
+    try {
+      const val = await redis.sendCommand(['GET', key]);
+      return val ? parseInt(val, 10) : 1;
+    } catch {
+      // Fallback to local
+    }
+  }
+  return localCounters.get(key) || 1;
+}
+
+async function incrementVersion(app: any, key: string): Promise<number> {
+  const redis = getRedisClient(app);
+  if (redis) {
+    try {
+      const val = await redis.sendCommand(['INCR', key]);
+      return parseInt(val, 10);
+    } catch {
+      // Fallback to local
+    }
+  }
+  const next = (localCounters.get(key) || 1) + 1;
+  localCounters.set(key, next);
+  return next;
+}
+
+export const cacheVersionManager = {
+  async getCollectionVersion(app: any): Promise<number> {
+    return getVersion(app, 'nocobase:version:collections');
+  },
+
+  async incrementCollectionVersion(app: any): Promise<number> {
+    app.logger.info('[ClusterManager] Incrementing collections cache version due to schema change');
+    return incrementVersion(app, 'nocobase:version:collections');
+  },
+
+  async getSchemaVersion(app: any): Promise<number> {
+    return getVersion(app, 'nocobase:version:schemas');
+  },
+
+  async incrementSchemaVersion(app: any): Promise<number> {
+    app.logger.info('[ClusterManager] Incrementing uiSchemas cache version due to UI change');
+    return incrementVersion(app, 'nocobase:version:schemas');
+  },
+
+  async getAclVersion(app: any, roleName: string): Promise<number> {
+    return getVersion(app, `nocobase:version:acl:role:${roleName}`);
+  },
+
+  async incrementAclVersion(app: any, roleName: string): Promise<number> {
+    app.logger.info(`[ClusterManager] Incrementing ACL cache version for role: ${roleName}`);
+    return incrementVersion(app, `nocobase:version:acl:role:${roleName}`);
+  },
+
+  async incrementAllAclVersions(app: any): Promise<number> {
+    app.logger.info('[ClusterManager] Incrementing global ACL cache version');
+    return incrementVersion(app, 'nocobase:version:acl:global');
+  },
+
+  async getGlobalAclVersion(app: any): Promise<number> {
+    return getVersion(app, 'nocobase:version:acl:global');
+  },
+};

package/dist/client/AclCacheManager.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function AclCacheManager(): React.JSX.Element;

package/dist/client/CacheMonitor.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function CacheMonitor(): React.JSX.Element;

package/dist/client/ClusterManagerLayout.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function ClusterManagerLayout(): React.JSX.Element;

package/dist/client/ClusterNodes.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function ClusterNodes(): React.JSX.Element;

package/dist/client/ContainerOrchestrator.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function ContainerOrchestrator(): React.JSX.Element;

package/dist/client/EventQueueMonitor.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function EventQueueMonitor(): React.JSX.Element;

package/dist/client/LockMonitor.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function LockMonitor(): React.JSX.Element;

package/dist/client/PackageInstaller.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare const PackageInstaller: React.FC;

package/dist/client/PluginOperations.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function PluginOperations(): React.JSX.Element;

package/dist/client/RedisMonitor.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function RedisMonitor(): React.JSX.Element;

package/dist/client/TaskManager.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function TaskManager(): React.JSX.Element;

package/dist/client/WorkflowExecutions.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function WorkflowExecutions(): React.JSX.Element;

package/dist/client/index.d.ts

@@ -1,5 +0,0 @@
-import { Plugin } from '@nocobase/client';
-export declare class PluginClusterManagerClient extends Plugin {
-    load(): Promise<void>;
-}
-export default PluginClusterManagerClient;

package/dist/client/utils.d.ts

@@ -1,12 +0,0 @@
-/**
- * Shared i18n hook for the cluster-manager plugin.
- */
-export declare function useT(): (key: string) => string;
-/**
- * Format bytes into human-readable string (B, KB, MB, GB).
- */
-export declare function formatBytes(bytes: number): string;
-/**
- * Format seconds into human-readable uptime string (e.g., "2d 5h 30m").
- */
-export declare function formatUptime(seconds: number): string;

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from './server';
-export { default } from './server';

package/dist/server/actions/acl-cache.d.ts

@@ -1,53 +0,0 @@
-import { Context } from '@nocobase/actions';
-/**
- * In-memory ACL stats counter.
- * Tracks total checks, cache hits/misses per role:resource:action.
- */
-export interface AclCacheStats {
-    totalChecks: number;
-    cacheHits: number;
-    cacheMisses: number;
-    startedAt: string;
-    detailByRole: Record<string, {
-        checks: number;
-        hits: number;
-        misses: number;
-    }>;
-}
-/**
- * Middleware that caches the permission object computed by the ACL middleware.
- * Install via: app.acl.use(aclCacheMiddleware, { tag: 'aclCache', before: 'core', after: 'allow-manager' })
- *
- * FIX: Previously monkey-patched ctx.app.acl.can per-request, which is a race condition
- * because acl is a shared singleton across concurrent requests. Now we use a post-check
- * approach that reads from cache first and writes after the ACL middleware runs, without
- * ever replacing the shared acl.can method.
- */
-export declare function createAclCacheMiddleware(app: any): (ctx: Context, next: () => Promise<void>) => Promise<void>;
-export declare const aclCacheActions: {
-    /**
-     * GET /clusterManagerAclCache:stats
-     * Returns ACL cache hit/miss statistics
-     */
-    stats(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerAclCache:listKeys
-     * Lists all cached ACL permission keys
-     */
-    listKeys(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerAclCache:clear
-     * Clear all ACL cache entries and reset stats
-     */
-    clear(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerAclCache:resetStats
-     * Reset the in-memory ACL stats counters
-     */
-    resetStats(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerAclCache:clearRole
-     * Clear ACL cache entries for a specific role
-     */
-    clearRole(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/cache-monitor.d.ts

@@ -1,23 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const cacheMonitorActions: {
-    /**
-     * GET /clusterManagerCacheMgr:stores
-     * List all registered cache stores and their config
-     */
-    stores(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCacheMgr:caches
-     * List all created named caches
-     */
-    caches(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCacheMgr:redisMemory
-     * Get Redis memory usage for cache keys
-     */
-    redisMemory(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerCacheMgr:flushAll
-     * Flush all caches via CacheManager
-     */
-    flushAll(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/cluster-nodes.d.ts

@@ -1,49 +0,0 @@
-import { Context } from '@nocobase/actions';
-/**
- * Read the last N lines from the local system log file.
- * Extracted so it can be called from both the HTTP action and the PubSub subscriber.
- */
-export declare function readLocalLogs(app: any, maxLines: number): Promise<{
-    node: {
-        hostname: string;
-        pid: number;
-        workerMode: string;
-    };
-    lines: string[];
-    file: string;
-}>;
-export declare const clusterActions: {
-    /**
-     * GET /clusterManagerCluster:current
-     * Always returns info about the APP node (not workers).
-     * If this request is handled by a worker, we look up the APP node from Redis.
-     */
-    current(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCluster:list
-     * Returns all known cluster environments/nodes (if discovery adapter supports it)
-     */
-    list(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCluster:health
-     * Health check for all subsystems
-     */
-    health(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerCluster:restart
-     * Publishes a restart signal to target nodes orchestrating a soft NocoBase restart or a hard docker daemon rebirth
-     */
-    restart(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerCluster:logs?targetNodeId=xxx&lines=200
-     *
-     * HA-aware log viewer. Reads logs from a specific node in the cluster.
-     *
-     * Flow:
-     *  1. If targetNodeId matches current node (or is empty) → read local FS directly
-     *  2. Otherwise → publish a log request via PubSub → target node reads its local FS
-     *     and writes the result to a Redis key → this handler polls Redis until the
-     *     response arrives (max 10s) → returns it to the client
-     */
-    logs(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/event-queue-monitor.d.ts

@@ -1,13 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const eventQueueActions: {
-    /**
-     * GET /clusterManagerQueue:stats
-     * Returns event queue statistics
-     */
-    stats(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerQueue:messages
-     * List pending messages in a specific channel (memory adapter only)
-     */
-    messages(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/lock-monitor.d.ts

@@ -1,19 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const lockActions: {
-    /**
-     * GET /clusterManagerLock:info
-     * Returns lock manager info
-     */
-    info(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerLock:list
-     * List active locks
-     */
-    list(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /clusterManagerLock:release
-     * Force release a stuck lock (admin emergency action)
-     * Uses compare-and-swap via DEL for Redis locks with the correct key prefix.
-     */
-    release(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/orchestrator.d.ts

@@ -1,58 +0,0 @@
-/**
- * Orchestrator Actions
- *
- * API endpoints for container management. Write operations (scale, start, stop, remove)
- * are guarded by leader election — only the leader node can execute them.
- */
-import { Context } from '@nocobase/actions';
-export declare const orchestratorActions: {
-    /**
-     * GET /workerOrchestrator:ping
-     * Test connectivity to the container runtime
-     */
-    ping(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /workerOrchestrator:containers?stackId=1
-     * List live containers for a stack
-     */
-    containers(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /workerOrchestrator:scale
-     * Body: { stackId: 1, replicas: 3 }
-     * Leader-only
-     */
-    scale(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /workerOrchestrator:start
-     * Body: { stackId: 1, containerId: "abc123" }
-     * Leader-only
-     */
-    start(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /workerOrchestrator:stop
-     * Body: { stackId: 1, containerId: "abc123" }
-     * Leader-only
-     */
-    stop(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * POST /workerOrchestrator:remove
-     * Body: { stackId: 1, containerId: "abc123" }
-     * Leader-only
-     */
-    remove(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /workerOrchestrator:stats?containerId=abc123
-     * Get real-time stats for a container
-     */
-    stats(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /workerOrchestrator:logs?containerId=abc123&tail=100
-     * Get tail logs from a container
-     */
-    logs(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /workerOrchestrator:networks
-     * List available networks (if supported by adapter)
-     */
-    networks(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/package-manager.d.ts

@@ -1,6 +0,0 @@
-export declare const packageManagerActions: {
-    installPackages(ctx: any, next: () => Promise<void>): Promise<void>;
-    getPackageConfig(ctx: any, next: () => Promise<void>): Promise<void>;
-    savePackageConfig(ctx: any, next: () => Promise<void>): Promise<void>;
-    resetInitStatus(ctx: any, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/plugin-operations.d.ts

@@ -1,6 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const pluginOperationsActions: {
-    list(ctx: Context, next: () => Promise<void>): Promise<void>;
-    forceDisable(ctx: Context, next: () => Promise<void>): Promise<void>;
-    forceRemove(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/redis-monitor.d.ts

@@ -1,12 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const redisActions: {
-    info(ctx: Context, next: () => Promise<void>): Promise<void>;
-    clients(ctx: Context, next: () => Promise<void>): Promise<void>;
-    pubsub(ctx: Context, next: () => Promise<void>): Promise<void>;
-    slowlog(ctx: Context, next: () => Promise<void>): Promise<void>;
-    /**
-     * GET /clusterManagerRedis:syncMessages
-     * Returns info about NocoBase sync message channels (pub/sub layer)
-     */
-    syncMessages(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/tasks.d.ts

@@ -1,7 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const tasksActions: {
-    list(ctx: Context, next: () => Promise<void>): Promise<void>;
-    cancel(ctx: Context, next: () => Promise<void>): Promise<void>;
-    retry(ctx: Context, next: () => Promise<void>): Promise<void>;
-    purge(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/actions/workflow-executions.d.ts

@@ -1,7 +0,0 @@
-import { Context } from '@nocobase/actions';
-export declare const workflowActions: {
-    list(ctx: Context, next: () => Promise<void>): Promise<void>;
-    getJobs(ctx: Context, next: () => Promise<void>): Promise<void>;
-    cancel(ctx: Context, next: () => Promise<void>): Promise<void>;
-    purge(ctx: Context, next: () => Promise<void>): Promise<void>;
-};

package/dist/server/adapters/redis-lock-adapter.d.ts

@@ -1,15 +0,0 @@
-import { ILockAdapter, ILock, Releaser } from '@nocobase/lock-manager';
-import { Application } from '@nocobase/server';
-export declare class RedisLockAdapter implements ILockAdapter {
-    private options;
-    private client;
-    constructor(options: {
-        url?: string;
-        app: Application;
-    });
-    connect(): Promise<void>;
-    close(): Promise<void>;
-    acquire(key: string, ttl: number): Promise<Releaser>;
-    runExclusive<T>(key: string, fn: () => Promise<T>, ttl: number): Promise<T>;
-    tryAcquire(key: string, timeout?: number): Promise<ILock>;
-}

package/dist/server/adapters/redis-node-registry.d.ts

@@ -1,12 +0,0 @@
-export declare class RedisNodeRegistry {
-    private app;
-    private timer;
-    private readonly ttlSecs;
-    private readonly intervalMs;
-    private readonly keyPrefix;
-    constructor(app: any);
-    start(): void;
-    stop(): void;
-    private heartbeat;
-    getNodes(): Promise<any[]>;
-}