specrails-desktop 2.36.0 → 2.42.2

package/server/dist/background-process-control.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBackgroundProcessControl = createBackgroundProcessControl;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const win_spawn_1 = require("./util/win-spawn");
+function gone(error) { return error?.code === 'ESRCH'; }
+let windowsSnapshotPending;
+async function windowsSnapshot(fresh = false) {
+    // Multiple apps share the expensive OS query. After sending a signal wait
+    // out any earlier query and require a new snapshot to confirm termination.
+    if (fresh && windowsSnapshotPending)
+        await windowsSnapshotPending.catch(() => { });
+    if (windowsSnapshotPending)
+        return windowsSnapshotPending;
+    const env = (0, win_spawn_1.windowsSpawnEnv)();
+    const systemRoot = env.SystemRoot || env.windir || 'C:\\Windows';
+    const powershell = path_1.default.win32.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+    const script = "$ErrorActionPreference='Stop'; @(Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -gt 0 -and $null -ne $_.CreationDate } | Select-Object @{n='pid';e={[int]$_.ProcessId}},@{n='parentPid';e={[int]$_.ParentProcessId}},@{n='createdAt';e={$_.CreationDate.ToUniversalTime().ToString('o')}}) | ConvertTo-Json -Compress";
+    const pending = new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)(powershell, ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', script], {
+            env, windowsHide: true, timeout: 2500, maxBuffer: 4 * 1024 * 1024, encoding: 'utf8',
+        }, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            try {
+                const decoded = JSON.parse(stdout || '[]');
+                const rows = Array.isArray(decoded) ? decoded : [decoded];
+                if (rows.some(row => !row || !Number.isInteger(row.pid) || row.pid <= 0 || !Number.isInteger(row.parentPid) || row.parentPid < 0 || typeof row.createdAt !== 'string' || !Number.isFinite(Date.parse(row.createdAt)))) {
+                    throw new Error('Invalid Windows process identity snapshot.');
+                }
+                resolve(rows);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+    windowsSnapshotPending = pending;
+    try {
+        return await pending;
+    }
+    finally {
+        if (windowsSnapshotPending === pending)
+            windowsSnapshotPending = undefined;
+    }
+}
+/** POSIX children are launched in a dedicated session/group. Query and signal
+ * that group, not a rediscovered tree whose parent may already have exited.
+ * Windows uses creation-time identities plus taskkill /T /F; deliberately
+ * detached/breakaway processes require OS job containment and are not claimed
+ * to be contained here. A failed identity query must never report stopped. */
+function createBackgroundProcessControl(child, startedAt) {
+    const pid = child.pid;
+    if (process.platform !== 'win32') {
+        return {
+            async isAlive() {
+                try {
+                    process.kill(-pid, 0);
+                    return true;
+                }
+                catch (error) {
+                    if (gone(error))
+                        return false;
+                    throw error;
+                }
+            },
+            async terminate(signal) {
+                try {
+                    process.kill(-pid, signal);
+                }
+                catch (error) {
+                    if (!gone(error))
+                        throw error;
+                }
+            },
+        };
+    }
+    const owned = new Map();
+    let rootExited = false;
+    let identified = false;
+    let snapshotPending;
+    child.once('exit', () => { rootExited = true; });
+    child.once('close', () => { rootExited = true; });
+    const inspect = async (fresh = false) => {
+        if (fresh && snapshotPending)
+            await snapshotPending.catch(() => { });
+        if (snapshotPending)
+            return snapshotPending;
+        // Snapshot while the child handle still refers to our live root. A later
+        // process with the same pid must never become a new ownership anchor.
+        const canIdentifyRoot = !rootExited && !identified;
+        const pending = windowsSnapshot(fresh).then(rows => {
+            const current = new Map(rows.map(row => [row.pid, row]));
+            const root = current.get(pid);
+            if (canIdentifyRoot && !rootExited && root && Date.parse(root.createdAt) >= startedAt - 2000) {
+                owned.set(pid, root);
+                identified = true;
+            }
+            if (!identified)
+                throw new Error('Could not verify the Windows background process identity; stop cannot be confirmed.');
+            const live = new Map();
+            for (const [ownedPid, identity] of owned) {
+                const match = current.get(ownedPid);
+                if (match?.createdAt === identity.createdAt)
+                    live.set(ownedPid, match);
+            }
+            let changed = true;
+            while (changed) {
+                changed = false;
+                for (const row of rows) {
+                    const parent = live.get(row.parentPid);
+                    if (!live.has(row.pid) && parent && Date.parse(row.createdAt) >= Date.parse(parent.createdAt)) {
+                        live.set(row.pid, row);
+                        owned.set(row.pid, row);
+                        changed = true;
+                    }
+                }
+            }
+            return [...live.values()];
+        });
+        snapshotPending = pending;
+        try {
+            return await pending;
+        }
+        finally {
+            if (snapshotPending === pending)
+                snapshotPending = undefined;
+        }
+    };
+    // Begin capturing descendants before a stop request or a fast parent exit.
+    // A shared query may have begun before this particular bootstrap spawned.
+    // Retry once with a fresh bounded query while its child handle is still live.
+    const ready = inspect().catch(error => { if (rootExited)
+        throw error; return inspect(true); }).then(() => undefined);
+    void ready.catch(() => { });
+    return {
+        ready,
+        async isAlive() { return (await inspect()).length > 0; },
+        async terminate(signal) {
+            const live = await inspect();
+            const ids = new Set(live.map(row => row.pid));
+            const roots = live.filter(row => !ids.has(row.parentPid));
+            const errors = [];
+            await Promise.all(roots.map(row => new Promise(resolve => {
+                try {
+                    (0, win_spawn_1.treeKillSafe)(row.pid, signal, error => { if (error)
+                        errors.push(error); resolve(); });
+                }
+                catch (error) {
+                    errors.push(error);
+                    resolve();
+                }
+            })));
+            if ((await inspect(true)).length > 0 && errors.length)
+                throw errors[0];
+        },
+    };
+}

package/server/dist/background-process-service.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundProcessOwnershipLostError = void 0;
+exports.resolveBackgroundCwd = resolveBackgroundCwd;
+exports.backgroundProcessHooks = backgroundProcessHooks;
+exports.backgroundStartBusyReason = backgroundStartBusyReason;
+exports.stopOwnedBackgroundProcess = stopOwnedBackgroundProcess;
+const node_path_1 = __importDefault(require("node:path"));
+const loop_runs_store_1 = require("./loop-runs-store");
+const project_repositories_1 = require("./project-repositories");
+const transient_children_1 = require("./transient-children");
+/** The same scope and lifecycle policy applies to REST and the mission MCP. */
+function resolveBackgroundCwd(repositoryRoot, cwd) {
+    if (cwd !== undefined && typeof cwd !== 'string')
+        throw new project_repositories_1.RepositoryValidationError('cwd must be a string');
+    const resolved = node_path_1.default.resolve(repositoryRoot, typeof cwd === 'string' && cwd.trim() ? cwd : '.');
+    if (!(0, project_repositories_1.isRepositoryPathWithin)((0, project_repositories_1.canonicalRepositoryPath)(repositoryRoot), (0, project_repositories_1.canonicalRepositoryPath)(resolved))) {
+        throw new project_repositories_1.RepositoryValidationError('background_start cwd must stay within the selected repository.');
+    }
+    return resolved;
+}
+function backgroundProcessHooks(broadcast) {
+    const publish = (type) => (process) => broadcast({ type, process,
+        projectId: process.projectId, timestamp: new Date().toISOString() });
+    return { onStarted: publish('background_process.started'), onUpdated: publish('background_process.updated'), onExited: publish('background_process.exited') };
+}
+function backgroundStartBusyReason(c) {
+    const activeJobId = typeof c.queueManager?.getActiveJobId === 'function' ? c.queueManager.getActiveJobId() : null;
+    if (activeJobId)
+        return `job ${activeJobId} is still running`;
+    // Context-only fixtures have no database; a real database error must not
+    // silently bypass the concurrent-run guard.
+    if (!c.db)
+        return null;
+    const activeLoops = (0, loop_runs_store_1.listActiveLoopRuns)(c.db, c.project.id);
+    return activeLoops.length ? `loop run ${activeLoops[0].id} is still running` : null;
+}
+class BackgroundProcessOwnershipLostError extends Error {
+    status = 409;
+    constructor() {
+        super('This execution was recovered from history after Specrails restarted. Its current OS state is unknown, so its old PID cannot be used to stop it. Inspect its retained logs and the current application state first.');
+        this.name = 'BackgroundProcessOwnershipLostError';
+    }
+}
+exports.BackgroundProcessOwnershipLostError = BackgroundProcessOwnershipLostError;
+function stopOwnedBackgroundProcess(pid, owner) {
+    const process = (0, transient_children_1.getBackgroundProcess)(pid, owner.processId);
+    if (!process || process.projectId !== owner.projectId || process.chatId !== owner.chatId ||
+        (owner.processId !== undefined && process.processId !== owner.processId))
+        return null;
+    if (process.status === 'interrupted')
+        throw new BackgroundProcessOwnershipLostError();
+    if (['exited', 'killed', 'failed'].includes(process.status))
+        return process;
+    if (!(0, transient_children_1.killOwnedBackgroundProcess)(pid, owner))
+        return null;
+    return (0, transient_children_1.getBackgroundProcess)(pid, owner.processId);
+}

package/server/dist/background-process-store.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundProcessStore = exports.BACKGROUND_HISTORY_MAX_LINE_CHARS = exports.BACKGROUND_HISTORY_MAX_LINES = exports.BACKGROUND_HISTORY_RETENTION_MS = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const crypto_1 = require("crypto");
+const secure_fs_1 = require("./util/secure-fs");
+exports.BACKGROUND_HISTORY_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+exports.BACKGROUND_HISTORY_MAX_LINES = 10_000;
+exports.BACKGROUND_HISTORY_MAX_LINE_CHARS = 4000;
+const defaultPolicy = { retentionMs: exports.BACKGROUND_HISTORY_RETENTION_MS, maxFinishedRuns: 1000, maxLines: exports.BACKGROUND_HISTORY_MAX_LINES, maxTextBytes: 256 * 1024 * 1024 };
+const activeStatuses = "('starting','running','stopping')";
+/** Log volume stays in its own SQLite file so batched writes cannot hold the
+ * mission/conversation database lock. Only execution UUIDs identify history;
+ * opening this store never probes, adopts or signals an old operating-system PID. */
+class BackgroundProcessStore {
+    file;
+    db;
+    policy;
+    lastPrune = 0;
+    ownerToken = (0, crypto_1.randomUUID)();
+    constructor(file, policy = {}) {
+        this.file = file;
+        this.policy = { ...defaultPolicy, ...policy };
+        for (const value of Object.values(this.policy))
+            if (!Number.isSafeInteger(value) || value <= 0)
+                throw new Error('Background history limits must be positive integers.');
+        if (file !== ':memory:') {
+            fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+            (0, secure_fs_1.secureDir)(path_1.default.dirname(file));
+        }
+        this.db = new better_sqlite3_1.default(file);
+        try {
+            this.db.pragma('journal_mode = WAL');
+            this.db.pragma('foreign_keys = ON');
+            this.db.pragma('busy_timeout = 1000');
+            this.db.pragma('journal_size_limit = 10000000');
+            const version = this.db.pragma('user_version', { simple: true });
+            if (version > 1)
+                throw new Error('Background history was written by a newer Specrails version.');
+            if (version < 1)
+                this.db.transaction(() => {
+                    this.db.exec(`
+          CREATE TABLE background_process_runs (
+            process_id TEXT PRIMARY KEY,
+            pid INTEGER NOT NULL,
+            project_id TEXT NOT NULL,
+            chat_id TEXT NOT NULL,
+            started_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL,
+            status TEXT NOT NULL CHECK(status IN ('starting','running','stopping','exited','killed','failed','interrupted')),
+            metadata TEXT NOT NULL,
+            next_sequence INTEGER NOT NULL DEFAULT 0,
+            clipped INTEGER NOT NULL DEFAULT 0,
+            line_count INTEGER NOT NULL DEFAULT 0,
+            text_bytes INTEGER NOT NULL DEFAULT 0
+          );
+          CREATE INDEX background_process_owner ON background_process_runs(project_id, chat_id, started_at DESC);
+          CREATE INDEX background_process_retention ON background_process_runs(status, updated_at);
+          CREATE TABLE background_process_lines (
+            process_id TEXT NOT NULL REFERENCES background_process_runs(process_id) ON DELETE CASCADE,
+            sequence INTEGER NOT NULL,
+            at INTEGER NOT NULL,
+            source TEXT NOT NULL CHECK(source IN ('stdout','stderr')),
+            line TEXT NOT NULL,
+            partial INTEGER NOT NULL,
+            text_bytes INTEGER NOT NULL,
+            PRIMARY KEY(process_id, sequence)
+          ) WITHOUT ROWID;
+          PRAGMA user_version = 1;
+        `);
+                })();
+            this.db.exec('CREATE TABLE IF NOT EXISTS background_process_session_owner (slot INTEGER PRIMARY KEY CHECK(slot=1), pid INTEGER NOT NULL, token TEXT NOT NULL)');
+            this.db.transaction(() => {
+                const owner = this.db.prepare('SELECT pid,token FROM background_process_session_owner WHERE slot=1').get();
+                if (owner) {
+                    let dead = false;
+                    if (Number.isSafeInteger(owner.pid) && owner.pid > 0) {
+                        try {
+                            process.kill(owner.pid, 0);
+                        }
+                        catch (error) {
+                            dead = error.code === 'ESRCH';
+                        }
+                    }
+                    if (!dead)
+                        throw new Error('Background process history is already owned by another active Specrails server.');
+                }
+                this.db.prepare('INSERT OR REPLACE INTO background_process_session_owner(slot,pid,token) VALUES(1,?,?)').run(process.pid, this.ownerToken);
+                this.recover();
+                this.prune(true);
+            }).immediate();
+            (0, secure_fs_1.secureDbFile)(file);
+        }
+        catch (error) {
+            this.db.close();
+            throw error;
+        }
+    }
+    recover() {
+        const now = Date.now();
+        const rows = this.db.prepare(`SELECT process_id, metadata FROM background_process_runs WHERE status IN ${activeStatuses}`).all();
+        const update = this.db.prepare("UPDATE background_process_runs SET status='interrupted', metadata=?, updated_at=? WHERE process_id=?");
+        this.db.transaction(() => {
+            for (const row of rows) {
+                const process = JSON.parse(row.metadata);
+                process.status = 'interrupted';
+                process.recoveredAt = now;
+                process.error = 'Specrails restarted before process exit could be confirmed. This historical process is not attached to this session.';
+                update.run(JSON.stringify(process), now, row.process_id);
+            }
+        })();
+    }
+    write(input) {
+        const { process } = input;
+        const lines = input.lines.map(line => ({ ...line, partial: line.partial === true ? 1 : 0, text_bytes: Buffer.byteLength(line.line, 'utf8') }));
+        this.db.transaction(() => {
+            const result = this.db.prepare(`INSERT INTO background_process_runs(process_id,pid,project_id,chat_id,started_at,updated_at,status,metadata,next_sequence,clipped)
+        VALUES(?,?,?,?,?,?,?,?,?,?) ON CONFLICT(process_id) DO UPDATE SET updated_at=excluded.updated_at,status=excluded.status,metadata=excluded.metadata,
+          next_sequence=MAX(background_process_runs.next_sequence,excluded.next_sequence),clipped=MAX(background_process_runs.clipped,excluded.clipped)
+        WHERE background_process_runs.pid=excluded.pid AND background_process_runs.project_id=excluded.project_id AND background_process_runs.chat_id=excluded.chat_id`)
+                .run(process.processId, process.pid, process.projectId, process.chatId, process.startedAt, Date.now(), process.status, JSON.stringify(process), input.nextSequence, input.clipped ? 1 : 0);
+            if (!result.changes)
+                throw new Error('Background process history identity does not match its original owner.');
+            if (lines.length)
+                this.db.prepare(`INSERT INTO background_process_lines(process_id,sequence,at,source,line,partial,text_bytes)
+        SELECT ?,json_extract(value,'$.sequence'),json_extract(value,'$.at'),json_extract(value,'$.source'),json_extract(value,'$.line'),json_extract(value,'$.partial'),json_extract(value,'$.text_bytes') FROM json_each(?) WHERE 1
+        ON CONFLICT(process_id,sequence) DO UPDATE SET line=excluded.line,partial=excluded.partial,text_bytes=excluded.text_bytes`)
+                    .run(process.processId, JSON.stringify(lines));
+            this.db.prepare(`DELETE FROM background_process_lines WHERE process_id=? AND sequence NOT IN
+        (SELECT sequence FROM background_process_lines WHERE process_id=? ORDER BY sequence DESC LIMIT ?)`)
+                .run(process.processId, process.processId, this.policy.maxLines);
+            this.recount(process.processId);
+            this.prune(false);
+        })();
+    }
+    recount(processId) {
+        this.db.prepare(`UPDATE background_process_runs SET line_count=(SELECT COUNT(*) FROM background_process_lines WHERE process_id=?),
+      text_bytes=(SELECT COALESCE(SUM(text_bytes),0) FROM background_process_lines WHERE process_id=?) WHERE process_id=?`).run(processId, processId, processId);
+    }
+    /** Retention prunes records/text, then SQLite reuses its freed pages. The
+     * finite text ceiling therefore also bounds repeated long-running sessions. */
+    prune(force = false) {
+        const now = Date.now();
+        if (!force && now - this.lastPrune < 1000) {
+            const totals = this.db.prepare(`SELECT COALESCE(SUM(text_bytes),0) AS bytes,SUM(CASE WHEN status NOT IN ${activeStatuses} THEN 1 ELSE 0 END) AS finished FROM background_process_runs`).get();
+            if (totals.bytes <= this.policy.maxTextBytes && totals.finished <= this.policy.maxFinishedRuns)
+                return;
+        }
+        this.db.transaction(() => {
+            this.db.prepare(`DELETE FROM background_process_runs WHERE status NOT IN ${activeStatuses} AND updated_at < ?`).run(now - this.policy.retentionMs);
+            this.db.prepare(`DELETE FROM background_process_runs WHERE process_id IN (SELECT process_id FROM background_process_runs WHERE status NOT IN ${activeStatuses}
+        ORDER BY updated_at DESC,started_at DESC,process_id DESC LIMIT -1 OFFSET ?)`).run(this.policy.maxFinishedRuns);
+            let total = this.db.prepare('SELECT COALESCE(SUM(text_bytes),0) AS bytes FROM background_process_runs').get().bytes;
+            if (total > this.policy.maxTextBytes) {
+                const rows = this.db.prepare(`SELECT process_id,text_bytes,status FROM background_process_runs ORDER BY CASE WHEN status IN ${activeStatuses} THEN 1 ELSE 0 END,updated_at,started_at`).all();
+                for (const row of rows) {
+                    if (total <= this.policy.maxTextBytes)
+                        break;
+                    if (!['starting', 'running', 'stopping'].includes(row.status)) {
+                        this.db.prepare('DELETE FROM background_process_runs WHERE process_id=?').run(row.process_id);
+                        total -= row.text_bytes;
+                    }
+                    else {
+                        this.db.prepare(`DELETE FROM background_process_lines WHERE process_id=? AND sequence IN (
+              SELECT sequence FROM (SELECT sequence,SUM(text_bytes) OVER (ORDER BY sequence)-text_bytes AS preceding_bytes FROM background_process_lines WHERE process_id=?) WHERE preceding_bytes < ?)`)
+                            .run(row.process_id, row.process_id, total - this.policy.maxTextBytes);
+                        this.recount(row.process_id);
+                        const remaining = this.db.prepare('SELECT text_bytes FROM background_process_runs WHERE process_id=?').get(row.process_id).text_bytes;
+                        total -= row.text_bytes - remaining;
+                    }
+                }
+            }
+        })();
+        this.lastPrune = now;
+    }
+    get(pid, processId) {
+        this.prune();
+        const row = (processId
+            ? this.db.prepare('SELECT metadata FROM background_process_runs WHERE pid=? AND process_id=?').get(pid, processId)
+            : this.db.prepare('SELECT metadata FROM background_process_runs WHERE pid=? ORDER BY started_at DESC,rowid DESC LIMIT 1').get(pid));
+        return row ? JSON.parse(row.metadata) : null;
+    }
+    list(filter = {}) {
+        this.prune();
+        const clauses = [], params = [];
+        if (filter.projectId) {
+            clauses.push('project_id=?');
+            params.push(filter.projectId);
+        }
+        if (filter.chatId) {
+            clauses.push('chat_id=?');
+            params.push(filter.chatId);
+        }
+        if (!filter.includeFinished)
+            clauses.push(`status IN ${activeStatuses}`);
+        const rows = this.db.prepare(`SELECT metadata FROM background_process_runs ${clauses.length ? `WHERE ${clauses.join(' AND ')}` : ''} ORDER BY started_at,rowid`).all(...params);
+        return rows.map(row => JSON.parse(row.metadata));
+    }
+    logs(pid, filter = {}) {
+        const process = this.get(pid, filter.processId);
+        if (!process || (filter.projectId && process.projectId !== filter.projectId) || (filter.chatId && process.chatId !== filter.chatId))
+            return null;
+        const row = this.db.prepare('SELECT next_sequence,clipped,line_count FROM background_process_runs WHERE process_id=?').get(process.processId);
+        const limit = typeof filter.limit === 'number' && Number.isFinite(filter.limit) ? Math.max(1, Math.min(this.policy.maxLines, Math.floor(filter.limit))) : 2000;
+        const lines = this.db.prepare('SELECT sequence,at,source,line,partial FROM background_process_lines WHERE process_id=? ORDER BY sequence DESC LIMIT ?').all(process.processId, limit)
+            .reverse().map(line => ({ ...line, partial: line.partial === 1 }));
+        const droppedLines = Math.max(0, row.next_sequence - lines.length);
+        return { process, lines, nextSequence: row.next_sequence, truncated: droppedLines > 0 || !!row.clipped, droppedLines,
+            maxLines: this.policy.maxLines, maxLineChars: exports.BACKGROUND_HISTORY_MAX_LINE_CHARS, retentionMs: this.policy.retentionMs };
+    }
+    close() {
+        if (!this.db.open)
+            return;
+        try {
+            this.db.prepare('DELETE FROM background_process_session_owner WHERE slot=1 AND token=?').run(this.ownerToken);
+            this.db.pragma('wal_checkpoint(TRUNCATE)');
+        }
+        finally {
+            this.db.close();
+        }
+    }
+    purge(filter) {
+        if (!filter.projectId && !filter.chatId)
+            throw new Error('A conversation or project is required to purge background history.');
+        const clauses = [], params = [];
+        if (filter.projectId) {
+            clauses.push('project_id=?');
+            params.push(filter.projectId);
+        }
+        if (filter.chatId) {
+            clauses.push('chat_id=?');
+            params.push(filter.chatId);
+        }
+        this.db.prepare(`DELETE FROM background_process_runs WHERE ${clauses.join(' AND ')}`).run(...params);
+    }
+}
+exports.BackgroundProcessStore = BackgroundProcessStore;