seendiff 0.0.2

package/src/server.js

@@ -0,0 +1,580 @@
+import Fastify from "fastify";
+import fastifyCompress from "@fastify/compress";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, readdirSync, rmSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+
+import * as G from "./git.js";
+import * as H from "./highlight.js";
+import * as store from "./store.js";
+import * as W from "./walkthrough.js";
+import { themeCss } from "./theme.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const STATIC = path.join(__dirname, "..", "static");
+
+const ALLOWED_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
+if (process.env.SEENDIFF_ALLOW_HOST) {
+    ALLOWED_HOSTS.add(process.env.SEENDIFF_ALLOW_HOST);
+}
+const CACHE_PRUNE_DAYS = 30;
+const SEARCH_LIMIT = 500;
+
+export function cacheRoot() {
+    const base = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+    return path.join(base, "seendiff");
+}
+
+export function pruneCache(root, days = CACHE_PRUNE_DAYS) {
+    if (!existsSync(root)) return;
+    let entries;
+    try {
+        entries = readdirSync(root, { withFileTypes: true });
+    } catch {
+        return;
+    }
+    const cutoff = Date.now() - days * 86400 * 1000;
+    for (const d of entries) {
+        if (!d.isDirectory()) continue;
+        const full = path.join(root, d.name);
+        try {
+            const st = statSync(full);
+            if (st.mtimeMs < cutoff) rmSync(full, { recursive: true, force: true });
+        } catch {
+            // best-effort
+        }
+    }
+}
+
+function weight(b) {
+    return G.decorateBlock(b).added + G.decorateBlock(b).removed || 1;
+}
+
+function counts(fd, states) {
+    let seen = 0;
+    let reviewed = 0;
+    let wTot = 0;
+    let wSeen = 0;
+    let wRev = 0;
+    for (const b of fd.blocks) {
+        const w = weight(b);
+        wTot += w;
+        const [s, r] = states.get(`${fd.path}\u0000${b.hunkId}`) || [null, null];
+        if (r) {
+            reviewed++;
+            wRev += w;
+        } else if (s) {
+            seen++;
+            wSeen += w;
+        }
+    }
+    return { n: fd.blocks.length, seen, reviewed, wTot, wSeen, wRev };
+}
+
+export class AppState {
+    constructor({ repo, baseRef, noHighlight = false, autoSeen = true, sectionMin = G.SECTION_MIN, sectionMax = G.SECTION_MAX, dbPath = null, wtFile = null }) {
+        this.repo = repo;
+        this.baseRef = baseRef;
+        this.noHighlight = noHighlight;
+        this.autoSeen = autoSeen;
+        this.sectionMin = sectionMin;
+        this.sectionMax = sectionMax;
+        this.dbPath = dbPath;
+
+        this.mbSha = "";
+        this.headSha = "";
+        this.baseDate = "";
+        this.branch = null;
+        this.scope = "";
+        this.files = [];
+        this.byPath = new Map();
+        this.dirty = [];
+        this.conflicted = [];
+        this.fileCache = new Map();
+
+        this.wtFile = wtFile;
+        this.wt = null;
+        this.wtEmpty = true;
+        this.wtError = null;
+        this.wtAttemptMtime = -1.0;
+        this.wtPaths = new Set();
+        this.wtCache = new Map();
+    }
+
+    hunkIds() {
+        const out = {};
+        for (const [p, fd] of this.byPath) {
+            out[p] = new Set(fd.blocks.map((b) => b.hunkId));
+        }
+        return out;
+    }
+
+    _recomputeWtPaths() {
+        if (!this.wt) {
+            this.wtPaths = new Set();
+            return;
+        }
+        const wtPaths = W.walkthroughPaths(this.wt);
+        this.wtPaths = new Set([...wtPaths].filter((p) => !this.byPath.has(p)));
+    }
+
+    loadWalkthrough() {
+        if (!this.wtFile) return;
+        let mtime;
+        try {
+            mtime = statSync(this.wtFile).mtimeMs;
+        } catch (e) {
+            if (e.code === "ENOENT") {
+                this.wt = null;
+                this.wtError = null;
+                this.wtEmpty = true;
+                this.wtAttemptMtime = -1.0;
+                this._recomputeWtPaths();
+                return;
+            }
+            this.wtError = `cannot stat walkthrough: ${e.message}`;
+            return;
+        }
+        if (mtime === this.wtAttemptMtime) return;
+        this.wtAttemptMtime = mtime;
+        try {
+            this.wt = W.load(this.wtFile, this.repo, this.hunkIds());
+            this.wtEmpty = this.wt === null;
+            this.wtError = null;
+            this.wtCache.clear();
+            this._recomputeWtPaths();
+        } catch (e) {
+            if (e instanceof W.WalkthroughError) {
+                this.wtError = e.problems.join("\n");
+            } else {
+                throw e;
+            }
+        }
+    }
+
+    refresh() {
+        this.mbSha = G.mergeBase(this.repo, this.baseRef);
+        this.headSha = G.revSha(this.repo);
+        this.baseDate = G.commitDate(this.repo, this.mbSha);
+        this.branch = G.branchName(this.repo);
+        this.scope = store.scopeKey(this.repo, this.baseRef, this.branch, this.mbSha);
+        this.files = G.expandSubmodules(
+            this.repo,
+            G.identityDiff(this.repo, this.mbSha, "HEAD", this.sectionMin, this.sectionMax),
+            this.sectionMin,
+            this.sectionMax
+        );
+        this.byPath = new Map(this.files.map((f) => [f.path, f]));
+        const [dirty, conflicted] = G.dirtyAndConflicted(this.repo);
+        this.dirty = dirty;
+        this.conflicted = conflicted;
+        this.fileCache.clear();
+        this._recomputeWtPaths();
+    }
+
+    maybeRefresh() {
+        if (G.revSha(this.repo) !== this.headSha) {
+            this.refresh();
+        } else {
+            const [dirty, conflicted] = G.dirtyAndConflicted(this.repo);
+            this.dirty = dirty;
+            this.conflicted = conflicted;
+        }
+    }
+
+    diskCacheDir() {
+        return path.join(cacheRoot(), `${this.mbSha.slice(0, 12)}-${this.headSha.slice(0, 12)}`);
+    }
+}
+
+function fileStates(st, db) {
+    return store.getStates(db, st.scope);
+}
+
+function buildFilePayload(st, fd) {
+    const key = createHash("sha256").update(fd.path).digest("hex").slice(0, 16) + ".json";
+    const disk = path.join(st.diskCacheDir(), key);
+    if (st.fileCache.has(fd.path)) return st.fileCache.get(fd.path);
+    if (existsSync(disk)) {
+        try {
+            const payload = JSON.parse(readFileSync(disk, "utf8"));
+            st.fileCache.set(fd.path, payload);
+            return payload;
+        } catch {
+            // fall through to rebuild
+        }
+    }
+
+    const rows = G.displayRows(st.repo, st.mbSha, fd);
+    const toks = st.noHighlight ? null : H.highlightRows(rows, fd.path);
+    const skipReason = st.noHighlight ? null : H.guard(rows);
+    const lines = rows.map((r, i) => {
+        const line = { old: r.old, new: r.new, type: r.type };
+        if (r.hunkId) line.h = r.hunkId;
+        if (toks !== null) line.t = toks[i];
+        else line.text = r.text;
+        return line;
+    });
+    const payload = {
+        path: fd.path,
+        old_path: fd.oldPath,
+        status: fd.status,
+        lang: toks !== null ? H.langFor(fd.path) || "text" : "text",
+        total_lines: rows.length,
+        highlighted: toks !== null,
+        skip_reason: skipReason,
+        block_meta: fd.blocks.map((b) => {
+            const db2 = G.decorateBlock(b);
+            return {
+                hunk_id: b.hunkId,
+                start: b.runs.length ? db2.newStart : 1,
+                end: b.runs.length ? db2.newEnd : Math.max(1, rows.length),
+                added: db2.added,
+                removed: db2.removed,
+                kind: b.runs.length ? db2.kind : "meta",
+            };
+        }),
+        lines,
+    };
+    st.fileCache.set(fd.path, payload);
+    try {
+        mkdirSync(path.dirname(disk), { recursive: true });
+        writeFileSync(disk, JSON.stringify(payload));
+    } catch {
+        // best-effort disk cache
+    }
+    return payload;
+}
+
+function lineText(line) {
+    if (line.t != null) return line.t.map((piece) => piece[1]).join("");
+    return line.text || "";
+}
+
+export async function createApp(st) {
+    const app = Fastify({ logger: false, bodyLimit: 1024 * 1024 * 64 });
+    await app.register(fastifyCompress, { threshold: 2048, encodings: ["gzip", "deflate", "br"] });
+
+    app.addContentTypeParser("*", { parseAs: "string" }, (request, body, done) => {
+        if (!body) return done(null, {});
+        try {
+            done(null, JSON.parse(body));
+        } catch {
+            done(null, {});
+        }
+    });
+
+    const db = store.openDb(st.dbPath);
+    st.refresh();
+    pruneCache(cacheRoot());
+    const themeCssStr = themeCss();
+
+    app.addHook("onRequest", async (request, reply) => {
+        const hostHeader = request.headers.host || "";
+        const host = hostHeader.split(":")[0];
+        if (!ALLOWED_HOSTS.has(host)) {
+            reply.code(403).type("text/plain").send("forbidden host");
+        }
+    });
+
+    app.get("/", { compress: false }, async (request, reply) => {
+        let html = readFileSync(path.join(STATIC, "index.html"), "utf8");
+        html = html.replace("__PREFS__", JSON.stringify(store.getPrefs(db)));
+        html = html.replace(
+            '<link rel="stylesheet" href="/theme.css">',
+            `<style>${themeCssStr}</style>`
+        );
+        reply.header("Cache-Control", "no-store").type("text/html").send(html);
+    });
+
+    app.get("/api/prefs", async () => store.getPrefs(db));
+
+    app.post("/api/prefs", async (request, reply) => {
+        const body = request.body || {};
+        const { key, value } = body;
+        if (typeof key !== "string" || typeof value !== "string") {
+            reply.code(400);
+            return { error: "key and value must be strings" };
+        }
+        store.setPref(db, key, value);
+        return { ok: true };
+    });
+
+    app.get("/theme.css", async (request, reply) => {
+        reply.header("Cache-Control", "max-age=86400").type("text/css").send(themeCssStr);
+    });
+
+    app.get("/fonts/:name", async (request, reply) => {
+        const name = request.params.name;
+        const fontsDir = path.resolve(path.join(STATIC, "fonts"));
+        const p = path.resolve(path.join(fontsDir, name));
+        if (!p.startsWith(fontsDir + path.sep) || !existsSync(p) || !statSync(p).isFile()) {
+            reply.code(404);
+            return { error: "not found" };
+        }
+        reply.header("Cache-Control", "max-age=31536000");
+        reply.send(readFileSync(p));
+    });
+
+    app.get("/api/files", async () => {
+        st.maybeRefresh();
+        const states = fileStates(st, db);
+        const files = [];
+        let tot = 0;
+        let totSeen = 0;
+        let totRev = 0;
+        let wTot = 0;
+        let wSeen = 0;
+        let wRev = 0;
+        for (const fd of st.files) {
+            const c = counts(fd, states);
+            tot += c.n;
+            totSeen += c.seen;
+            totRev += c.reviewed;
+            wTot += c.wTot;
+            wSeen += c.wSeen;
+            wRev += c.wRev;
+            files.push({
+                path: fd.path,
+                old_path: fd.oldPath,
+                status: fd.status,
+                added: fd.added,
+                removed: fd.removed,
+                blocks: c.n,
+                seen: c.seen,
+                reviewed: c.reviewed,
+                weight: c.wTot,
+                seen_w: c.wSeen,
+                reviewed_w: c.wRev,
+            });
+        }
+        return {
+            scope: st.scope,
+            branch: st.branch,
+            base_ref: st.baseRef,
+            base_sha: st.mbSha.slice(0, 12),
+            base_date: st.baseDate,
+            head_sha: st.headSha.slice(0, 12),
+            dirty_files: st.dirty,
+            conflicted_files: st.conflicted,
+            auto_seen: st.autoSeen,
+            stats: { blocks: tot, seen: totSeen, reviewed: totRev, weight: wTot, seen_w: wSeen, reviewed_w: wRev },
+            files,
+        };
+    });
+
+    function worktreePayload(filePath) {
+        let mtime;
+        try {
+            mtime = statSync(path.join(st.repo, filePath)).mtimeMs;
+        } catch (e) {
+            const err = new Error(`cannot stat ${filePath}: ${e.message}`);
+            err.statusCode = 404;
+            throw err;
+        }
+        const key = `${filePath}\u0000${mtime}`;
+        if (st.wtCache.has(key)) return st.wtCache.get(key);
+        let rows;
+        try {
+            rows = G.worktreeRows(st.repo, filePath);
+        } catch (e) {
+            const err = new Error(e.message);
+            err.statusCode = 404;
+            throw err;
+        }
+        const toks = st.noHighlight ? null : H.highlightRows(rows, filePath);
+        const skipReason = st.noHighlight ? null : H.guard(rows);
+        const lines = rows.map((r, i) => {
+            const line = { old: r.old, new: r.new, type: r.type };
+            if (toks !== null) line.t = toks[i];
+            else line.text = r.text;
+            return line;
+        });
+        const payload = {
+            path: filePath,
+            old_path: null,
+            status: "worktree",
+            lang: toks !== null ? H.langFor(filePath) || "text" : "text",
+            total_lines: rows.length,
+            highlighted: toks !== null,
+            skip_reason: skipReason,
+            blocks: [],
+            lines,
+        };
+        for (const k of [...st.wtCache.keys()]) {
+            if (k.startsWith(`${filePath}\u0000`)) st.wtCache.delete(k);
+        }
+        st.wtCache.set(key, payload);
+        return payload;
+    }
+
+    app.get("/api/walkthrough", async (request, reply) => {
+        if (!st.wtFile) {
+            reply.code(404);
+            return { error: "no walkthrough loaded" };
+        }
+        st.maybeRefresh();
+        st.loadWalkthrough();
+        if (st.wt === null && st.wtEmpty) {
+            return { empty: true };
+        }
+        if (st.wt === null) {
+            reply.code(422);
+            return { error: "walkthrough failed to load:\n" + (st.wtError || "?") };
+        }
+        const out = W.walkthroughToJson(st.wt);
+        out.error = st.wtError;
+        out.wt_paths = [...st.wtPaths].sort();
+        return out;
+    });
+
+    app.post("/api/walkthrough/dismiss", async (request, reply) => {
+        if (!st.wtFile) {
+            reply.code(404);
+            return { error: "no walkthrough loaded" };
+        }
+        try {
+            writeFileSync(st.wtFile, "{}\n");
+        } catch (e) {
+            reply.code(500);
+            return { error: `cannot empty walkthrough: ${e.message}` };
+        }
+        st.loadWalkthrough();
+        return { empty: true };
+    });
+
+    app.get("/api/file", async (request, reply) => {
+        const filePath = request.query.path;
+        const fd = st.byPath.get(filePath);
+        if (fd === undefined) {
+            if (st.wtPaths.has(filePath)) {
+                try {
+                    return worktreePayload(filePath);
+                } catch (e) {
+                    reply.code(e.statusCode || 500);
+                    return { error: e.message };
+                }
+            }
+            reply.code(404);
+            return { error: `not in diff: ${filePath}` };
+        }
+        const payload = { ...buildFilePayload(st, fd) };
+        const states = fileStates(st, db);
+        const blockMeta = payload.block_meta;
+        delete payload.block_meta;
+        payload.blocks = blockMeta.map((bm) => {
+            const [s, r] = states.get(`${filePath}\u0000${bm.hunk_id}`) || [null, null];
+            return { ...bm, seen: Boolean(s), reviewed: Boolean(r) };
+        });
+        return payload;
+    });
+
+    app.get("/api/search", async (request, reply) => {
+        const q = request.query.q || "";
+        const regex = request.query.regex === "true" || request.query.regex === true;
+        const caseSensitive = request.query.case === "true" || request.query.case === true;
+        let limit = request.query.limit !== undefined ? parseInt(request.query.limit, 10) : SEARCH_LIMIT;
+        if (!q) return { q, total: 0, truncated: false, files: [] };
+        let rx;
+        try {
+            const pattern = regex ? q : q.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            rx = new RegExp(pattern, caseSensitive ? "" : "i");
+        } catch (e) {
+            reply.code(400);
+            return { error: `bad regex: ${e.message}` };
+        }
+        limit = Math.max(1, Math.min(limit || SEARCH_LIMIT, 5000));
+        st.maybeRefresh();
+        const out = [];
+        let total = 0;
+        let truncated = false;
+        for (const fd of st.files) {
+            if (truncated) break;
+            if (fd.status === "binary" || fd.status === "meta") continue;
+            const hits = [];
+            const payload = buildFilePayload(st, fd);
+            for (let i = 0; i < payload.lines.length; i++) {
+                const line = payload.lines[i];
+                const text = lineText(line);
+                const m = rx.exec(text);
+                if (m === null) continue;
+                hits.push({
+                    line: i,
+                    new: line.new,
+                    old: line.old,
+                    type: line.type,
+                    text: text.slice(0, 400),
+                    start: m.index,
+                    end: m.index + m[0].length,
+                });
+                total++;
+                if (total >= limit) {
+                    truncated = true;
+                    break;
+                }
+            }
+            if (hits.length) out.push({ path: fd.path, matches: hits });
+        }
+        return { q, total, truncated, files: out };
+    });
+
+    function validBlocks(items) {
+        const out = [];
+        for (const it of items || []) {
+            const fd = st.byPath.get(it.path || "");
+            if (fd && fd.blocks.some((b) => b.hunkId === it.hunk_id)) {
+                out.push([it.path, it.hunk_id]);
+            }
+        }
+        return out;
+    }
+
+    app.post("/api/seen", async (request) => {
+        const body = request.body || {};
+        const blocks = validBlocks(body.blocks);
+        if (blocks.length) store.markSeen(db, st.scope, blocks);
+        return { marked: blocks.length };
+    });
+
+    app.post("/api/reviewed", async (request, reply) => {
+        const body = request.body || {};
+        let blocks;
+        if (body.file !== undefined) {
+            const fd = st.byPath.get(body.file);
+            if (fd === undefined) {
+                reply.code(404);
+                return { error: `not in diff: ${body.file}` };
+            }
+            blocks = fd.blocks.map((b) => [fd.path, b.hunkId]);
+        } else {
+            blocks = validBlocks(body.blocks);
+        }
+        if (blocks.length) store.markReviewed(db, st.scope, blocks);
+        return { marked: blocks.length };
+    });
+
+    app.delete("/api/reviewed", async (request, reply) => {
+        const { path: qPath, hunk_id: hunkId, file, all } = request.query;
+        const isAll = all === "true" || all === true;
+        if (isAll) {
+            store.unmarkReviewed(db, st.scope, { all: true });
+        } else if (file !== undefined) {
+            store.unmarkReviewed(db, st.scope, { filePath: file });
+        } else if (qPath && hunkId) {
+            store.unmarkReviewed(db, st.scope, { blocks: [[qPath, hunkId]] });
+        } else {
+            reply.code(400);
+            return { error: "need ?all=, ?file= or ?path=&hunk_id=" };
+        }
+        return { ok: true };
+    });
+
+    app.delete("/api/state", async () => {
+        store.clearScope(db, st.scope);
+        return { ok: true };
+    });
+
+    return app;
+}

package/src/store.js

@@ -0,0 +1,128 @@
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+export const PRUNE_DAYS = 60;
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS block_state (
+  scope       TEXT NOT NULL,
+  path        TEXT NOT NULL,
+  hunk_id     TEXT NOT NULL,
+  seen_at     TEXT,
+  reviewed_at TEXT,
+  PRIMARY KEY (scope, path, hunk_id)
+);
+CREATE INDEX IF NOT EXISTS bs_scope ON block_state(scope);
+CREATE TABLE IF NOT EXISTS prefs (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+`;
+
+export function defaultDbPath() {
+    const stateHome = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
+    const d = path.join(stateHome, "seendiff");
+    mkdirSync(d, { recursive: true });
+    return path.join(d, "state.db");
+}
+
+export function scopeKey(repo, baseRef, branch, mbSha) {
+    return `${repo}|${baseRef}|${branch || mbSha}`;
+}
+
+function now() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, "+00:00");
+}
+
+export function openDb(dbPath = null) {
+    const db = new DatabaseSync(dbPath || defaultDbPath());
+    db.exec(SCHEMA);
+    prune(db);
+    return db;
+}
+
+export function prune(db, days = PRUNE_DAYS) {
+    const cutoff = new Date(Date.now() - days * 86400 * 1000).toISOString().replace(/\.\d{3}Z$/, "+00:00");
+    db.prepare(
+        "DELETE FROM block_state WHERE COALESCE(reviewed_at, '') < ? AND COALESCE(seen_at, '') < ?"
+    ).run(cutoff, cutoff);
+}
+
+export function getStates(db, scope) {
+    const rows = db
+        .prepare("SELECT path, hunk_id, seen_at, reviewed_at FROM block_state WHERE scope=?")
+        .all(scope);
+    const out = new Map();
+    for (const r of rows) {
+        out.set(`${r.path}\u0000${r.hunk_id}`, [r.seen_at ?? null, r.reviewed_at ?? null]);
+    }
+    return out;
+}
+
+export function markSeen(db, scope, blocks) {
+    const t = now();
+    const stmt = db.prepare(
+        `INSERT INTO block_state (scope, path, hunk_id, seen_at) VALUES (?,?,?,?)
+     ON CONFLICT(scope, path, hunk_id) DO UPDATE SET
+       seen_at = COALESCE(seen_at, excluded.seen_at)`
+    );
+    db.exec("BEGIN");
+    try {
+        for (const [p, h] of blocks) stmt.run(scope, p, h, t);
+        db.exec("COMMIT");
+    } catch (e) {
+        db.exec("ROLLBACK");
+        throw e;
+    }
+}
+
+export function markReviewed(db, scope, blocks) {
+    const t = now();
+    const stmt = db.prepare(
+        `INSERT INTO block_state (scope, path, hunk_id, seen_at, reviewed_at) VALUES (?,?,?,?,?)
+     ON CONFLICT(scope, path, hunk_id) DO UPDATE SET
+       seen_at = COALESCE(seen_at, excluded.seen_at),
+       reviewed_at = excluded.reviewed_at`
+    );
+    db.exec("BEGIN");
+    try {
+        for (const [p, h] of blocks) stmt.run(scope, p, h, t, t);
+        db.exec("COMMIT");
+    } catch (e) {
+        db.exec("ROLLBACK");
+        throw e;
+    }
+}
+
+export function unmarkReviewed(db, scope, { blocks = null, filePath = null, all = false } = {}) {
+    if (all) {
+        db.prepare("UPDATE block_state SET reviewed_at=NULL WHERE scope=?").run(scope);
+    } else if (filePath !== null) {
+        db.prepare("UPDATE block_state SET reviewed_at=NULL WHERE scope=? AND path=?").run(scope, filePath);
+    } else if (blocks && blocks.length) {
+        const stmt = db.prepare(
+            "UPDATE block_state SET reviewed_at=NULL WHERE scope=? AND path=? AND hunk_id=?"
+        );
+        for (const [p, h] of blocks) stmt.run(scope, p, h);
+    }
+}
+
+export function getPrefs(db) {
+    const rows = db.prepare("SELECT key, value FROM prefs").all();
+    const out = {};
+    for (const r of rows) out[r.key] = r.value;
+    return out;
+}
+
+export function setPref(db, key, value) {
+    db.prepare(
+        `INSERT INTO prefs (key, value) VALUES (?,?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(key, value);
+}
+
+export function clearScope(db, scope) {
+    db.prepare("DELETE FROM block_state WHERE scope=?").run(scope);
+}