@sporesec/arcana 2.3.1 → 3.0.0

package/dist/commands/lock.js

@@ -0,0 +1,171 @@
+import { readdirSync, readFileSync, existsSync, lstatSync } from "node:fs";
+import { join } from "node:path";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { getInstallDir, readSkillMeta } from "../utils/fs.js";
+import { readLockfile, writeLockfile, computeHash } from "../utils/integrity.js";
+import { renderBanner } from "../utils/help.js";
+import { printErrorWithHint } from "../utils/ui.js";
+function readSkillFiles(skillDir) {
+    const files = [];
+    const queue = [skillDir];
+    while (queue.length > 0) {
+        const dir = queue.pop();
+        for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            const stat = lstatSync(full);
+            if (stat.isDirectory())
+                queue.push(full);
+            else if (stat.isFile()) {
+                const relPath = full.slice(skillDir.length + 1).replace(/\\/g, "/");
+                files.push({ path: relPath, content: readFileSync(full, "utf-8") });
+            }
+        }
+    }
+    return files;
+}
+export async function lockCommand(opts) {
+    if (opts.ci) {
+        return ciMode(opts.json);
+    }
+    return generateMode(opts.json);
+}
+async function generateMode(json) {
+    if (!json) {
+        console.log(renderBanner());
+        console.log();
+        p.intro(chalk.bold("Generate lockfile"));
+    }
+    const installDir = getInstallDir();
+    if (!existsSync(installDir)) {
+        if (json) {
+            console.log(JSON.stringify({ action: "generate", entries: 0, path: "~/.arcana/arcana-lock.json" }));
+        }
+        else {
+            p.log.info("No skills installed. Lockfile written with 0 entries.");
+        }
+        writeLockfile([]);
+        return;
+    }
+    const dirs = readdirSync(installDir).filter((d) => {
+        try {
+            return lstatSync(join(installDir, d)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    const entries = [];
+    for (const name of dirs) {
+        const skillDir = join(installDir, name);
+        const files = readSkillFiles(skillDir);
+        const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+        const concatenated = sorted.map((f) => f.content).join("");
+        const hash = computeHash(concatenated);
+        const meta = readSkillMeta(name);
+        entries.push({
+            skill: name,
+            version: meta?.version ?? "0.0.0",
+            hash,
+            source: meta?.source ?? "unknown",
+            installedAt: meta?.installedAt ?? new Date().toISOString(),
+        });
+    }
+    writeLockfile(entries);
+    if (json) {
+        console.log(JSON.stringify({ action: "generate", entries: entries.length, path: "~/.arcana/arcana-lock.json" }));
+    }
+    else {
+        p.log.success(`Lockfile written with ${entries.length} entries.`);
+        p.outro(chalk.dim("~/.arcana/arcana-lock.json"));
+    }
+}
+async function ciMode(json) {
+    if (!json) {
+        console.log(renderBanner());
+        console.log();
+        p.intro(chalk.bold("Validate lockfile"));
+    }
+    const existing = readLockfile();
+    if (existing.length === 0) {
+        const lockPath = join(getInstallDir(), "..", "arcana-lock.json");
+        if (!existsSync(lockPath)) {
+            if (json) {
+                console.log(JSON.stringify({
+                    action: "ci",
+                    valid: false,
+                    mismatches: [],
+                    missing: [],
+                    extra: [],
+                    error: "No lockfile found",
+                }));
+            }
+            else {
+                printErrorWithHint(new Error("No lockfile found. Run `arcana lock` first to generate one."), true);
+            }
+            process.exit(1);
+        }
+    }
+    const installDir = getInstallDir();
+    const installedDirs = existsSync(installDir)
+        ? readdirSync(installDir).filter((d) => {
+            try {
+                return lstatSync(join(installDir, d)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })
+        : [];
+    const lockedNames = new Set(existing.map((e) => e.skill));
+    const installedNames = new Set(installedDirs);
+    const mismatches = [];
+    const missing = [];
+    const extra = [];
+    // Check each lockfile entry against installed state
+    for (const entry of existing) {
+        if (!installedNames.has(entry.skill)) {
+            missing.push(entry.skill);
+            continue;
+        }
+        const skillDir = join(installDir, entry.skill);
+        const files = readSkillFiles(skillDir);
+        const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+        const concatenated = sorted.map((f) => f.content).join("");
+        const hash = computeHash(concatenated);
+        if (hash !== entry.hash) {
+            mismatches.push(entry.skill);
+        }
+    }
+    // Check for extra skills not in lockfile
+    for (const name of installedDirs) {
+        if (!lockedNames.has(name)) {
+            extra.push(name);
+        }
+    }
+    const valid = mismatches.length === 0 && missing.length === 0 && extra.length === 0;
+    if (json) {
+        console.log(JSON.stringify({ action: "ci", valid, mismatches, missing, extra }));
+    }
+    else {
+        if (valid) {
+            p.log.success("Lockfile matches installed state.");
+            p.outro(chalk.dim("All entries verified."));
+        }
+        else {
+            if (mismatches.length > 0) {
+                p.log.error(`Hash mismatch: ${mismatches.join(", ")}`);
+            }
+            if (missing.length > 0) {
+                p.log.error(`Missing from disk: ${missing.join(", ")}`);
+            }
+            if (extra.length > 0) {
+                p.log.warn(`Extra (not in lockfile): ${extra.join(", ")}`);
+            }
+            p.outro(chalk.dim("Lockfile validation failed."));
+        }
+    }
+    if (!valid) {
+        process.exit(1);
+    }
+}

package/dist/commands/optimize.d.ts

@@ -0,0 +1,3 @@
+export declare function optimizeCommand(opts: {
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/optimize.js

@@ -0,0 +1,356 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { ui, banner } from "../utils/ui.js";
+import { getInstallDir, getDirSize } from "../utils/fs.js";
+function readSettings() {
+    const settingsPath = join(homedir(), ".claude", "settings.json");
+    if (!existsSync(settingsPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(settingsPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function checkAutocompact() {
+    const settings = readSettings();
+    if (!settings) {
+        return {
+            area: "Autocompact",
+            status: "suggest",
+            message: "No settings.json found",
+            action: "Set CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=80 in ~/.claude/settings.json env block",
+        };
+    }
+    const env = settings.env;
+    const val = env?.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE;
+    if (!val) {
+        return {
+            area: "Autocompact",
+            status: "suggest",
+            message: "Not configured (defaults to high threshold)",
+            action: "Set to 80 to compact earlier and save tokens",
+        };
+    }
+    const pct = parseInt(val);
+    if (pct <= 70) {
+        return {
+            area: "Autocompact",
+            status: "warn",
+            message: `Set to ${pct}%. Too aggressive, may lose context.`,
+            action: "Raise to 75-80% for better balance",
+        };
+    }
+    if (pct > 85) {
+        return {
+            area: "Autocompact",
+            status: "suggest",
+            message: `Set to ${pct}%. Compaction happens late, less room for reasoning.`,
+            action: "Lower to 80% for better quality (research-backed)",
+        };
+    }
+    return { area: "Autocompact", status: "good", message: `Set to ${pct}% (optimal range)` };
+}
+function checkEffortLevel() {
+    const settings = readSettings();
+    const env = (settings?.env ?? {});
+    const val = env.CLAUDE_CODE_EFFORT_LEVEL;
+    if (!val) {
+        return { area: "Effort level", status: "good", message: "Using default (high)" };
+    }
+    if (val === "low") {
+        return {
+            area: "Effort level",
+            status: "suggest",
+            message: "Set to 'low'. Faster but may miss details.",
+            action: "Use 'medium' for daily work, 'high' for complex tasks",
+        };
+    }
+    if (val === "medium") {
+        return { area: "Effort level", status: "good", message: "Set to 'medium'. Good balance of speed and quality." };
+    }
+    return { area: "Effort level", status: "good", message: `Set to '${val}'` };
+}
+function checkNonEssentialCalls() {
+    const settings = readSettings();
+    const env = (settings?.env ?? {});
+    const val = env.DISABLE_NON_ESSENTIAL_MODEL_CALLS;
+    if (val === "1" || val === "true") {
+        return { area: "Non-essential calls", status: "good", message: "Disabled (saves tokens)" };
+    }
+    return {
+        area: "Non-essential calls",
+        status: "suggest",
+        message: "Not disabled",
+        action: "Set DISABLE_NON_ESSENTIAL_MODEL_CALLS=1 in settings.json env to save tokens",
+    };
+}
+function checkSkillTokenBudget() {
+    const dir = getInstallDir();
+    if (!existsSync(dir)) {
+        return { area: "Skill token budget", status: "good", message: "No skills installed" };
+    }
+    let totalKB = 0;
+    let skillCount = 0;
+    const large = [];
+    for (const entry of readdirSync(dir)) {
+        const skillDir = join(dir, entry);
+        if (!statSync(skillDir).isDirectory())
+            continue;
+        skillCount++;
+        const kb = getDirSize(skillDir) / 1024;
+        totalKB += kb;
+        if (kb > 50)
+            large.push({ name: entry, kb });
+    }
+    const estTokens = Math.round(totalKB * 256);
+    if (totalKB > 500) {
+        large.sort((a, b) => b.kb - a.kb);
+        const topNames = large
+            .slice(0, 3)
+            .map((s) => s.name)
+            .join(", ");
+        return {
+            area: "Skill token budget",
+            status: "warn",
+            message: `${skillCount} skills, ${totalKB.toFixed(0)} KB (~${(estTokens / 1000).toFixed(0)}K tokens). Heavy context load.`,
+            action: `Consider uninstalling rarely used skills. Largest: ${topNames}`,
+        };
+    }
+    if (totalKB > 200) {
+        return {
+            area: "Skill token budget",
+            status: "suggest",
+            message: `${skillCount} skills, ${totalKB.toFixed(0)} KB (~${(estTokens / 1000).toFixed(0)}K tokens)`,
+            action: "Review installed skills with 'arcana list --installed' and remove unused ones",
+        };
+    }
+    return {
+        area: "Skill token budget",
+        status: "good",
+        message: `${skillCount} skills, ${totalKB.toFixed(0)} KB (~${(estTokens / 1000).toFixed(0)}K tokens)`,
+    };
+}
+function checkDiskHealth() {
+    const claudeDir = join(homedir(), ".claude");
+    if (!existsSync(claudeDir)) {
+        return { area: "Disk health", status: "good", message: "No Claude data directory" };
+    }
+    const totalMB = getDirSize(claudeDir) / (1024 * 1024);
+    if (totalMB > 1000) {
+        return {
+            area: "Disk health",
+            status: "warn",
+            message: `${totalMB.toFixed(0)} MB total Claude data`,
+            action: "Run: arcana compact (removes agent logs, keeps sessions)",
+        };
+    }
+    if (totalMB > 500) {
+        return {
+            area: "Disk health",
+            status: "suggest",
+            message: `${totalMB.toFixed(0)} MB total Claude data`,
+            action: "Run: arcana compact",
+        };
+    }
+    return { area: "Disk health", status: "good", message: `${totalMB.toFixed(0)} MB total Claude data` };
+}
+function checkPreCompactHook() {
+    // Check both global and local settings for PreCompact hooks
+    const paths = [join(homedir(), ".claude", "settings.json"), join(homedir(), ".claude", "settings.local.json")];
+    for (const settingsPath of paths) {
+        if (!existsSync(settingsPath))
+            continue;
+        try {
+            const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+            const hooks = settings?.hooks?.PreCompact;
+            if (hooks && Array.isArray(hooks) && hooks.length > 0) {
+                return { area: "PreCompact hook", status: "good", message: "Installed. Context preserved before compaction." };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return {
+        area: "PreCompact hook",
+        status: "suggest",
+        message: "Not installed. Context is lost during auto-compaction.",
+        action: "Run: arcana init --tool claude (adds PreCompact hook to preserve context)",
+    };
+}
+function checkMemorySize() {
+    const projectsDir = join(homedir(), ".claude", "projects");
+    if (!existsSync(projectsDir)) {
+        return { area: "MEMORY.md sizes", status: "good", message: "No project memory files" };
+    }
+    const oversized = [];
+    for (const entry of readdirSync(projectsDir)) {
+        const memDir = join(projectsDir, entry, "memory");
+        const memFile = join(memDir, "MEMORY.md");
+        if (!existsSync(memFile))
+            continue;
+        try {
+            const content = readFileSync(memFile, "utf-8");
+            const lineCount = content.split("\n").length;
+            if (lineCount > 200) {
+                oversized.push({ project: entry, lines: lineCount });
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    if (oversized.length === 0) {
+        return { area: "MEMORY.md sizes", status: "good", message: "All under 200 lines (auto-load limit)" };
+    }
+    oversized.sort((a, b) => b.lines - a.lines);
+    const top = oversized[0];
+    return {
+        area: "MEMORY.md sizes",
+        status: "warn",
+        message: `${oversized.length} MEMORY.md file${oversized.length > 1 ? "s" : ""} exceed 200 lines. Only first 200 auto-load. Worst: ${top.project} (${top.lines} lines)`,
+        action: "Trim to 200 lines. Move detailed notes to separate topic files in memory/",
+    };
+}
+function checkAgentBloat() {
+    const projectsDir = join(homedir(), ".claude", "projects");
+    if (!existsSync(projectsDir)) {
+        return { area: "Agent log bloat", status: "good", message: "No session data" };
+    }
+    let agentBytes = 0;
+    let mainBytes = 0;
+    let agentCount = 0;
+    let mainCount = 0;
+    for (const project of readdirSync(projectsDir)) {
+        const projDir = join(projectsDir, project);
+        if (!statSync(projDir).isDirectory())
+            continue;
+        for (const file of readdirSync(projDir)) {
+            if (!file.endsWith(".jsonl"))
+                continue;
+            try {
+                const size = statSync(join(projDir, file)).size;
+                if (file.startsWith("agent-")) {
+                    agentBytes += size;
+                    agentCount++;
+                }
+                else {
+                    mainBytes += size;
+                    mainCount++;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    const totalMB = (agentBytes + mainBytes) / (1024 * 1024);
+    const agentMB = agentBytes / (1024 * 1024);
+    const agentPct = totalMB > 0 ? Math.round((agentMB / totalMB) * 100) : 0;
+    if (agentPct > 70 && agentMB > 50) {
+        return {
+            area: "Agent log bloat",
+            status: "warn",
+            message: `${agentCount} agent logs (${agentMB.toFixed(0)} MB, ${agentPct}% of all logs). ${mainCount} main sessions (${(mainBytes / (1024 * 1024)).toFixed(0)} MB).`,
+            action: "Run: arcana compact (removes agent logs, keeps main sessions)",
+        };
+    }
+    if (agentMB > 20) {
+        return {
+            area: "Agent log bloat",
+            status: "suggest",
+            message: `${agentCount} agent logs (${agentMB.toFixed(0)} MB, ${agentPct}%). ${mainCount} main sessions.`,
+            action: "Run: arcana compact",
+        };
+    }
+    return {
+        area: "Agent log bloat",
+        status: "good",
+        message: `${agentCount} agent logs (${agentMB.toFixed(0)} MB), ${mainCount} main sessions (${(mainBytes / (1024 * 1024)).toFixed(0)} MB)`,
+    };
+}
+function checkLargestSkills() {
+    const dir = getInstallDir();
+    if (!existsSync(dir)) {
+        return { area: "Top skills by size", status: "good", message: "No skills installed" };
+    }
+    const skills = [];
+    for (const entry of readdirSync(dir)) {
+        const skillDir = join(dir, entry);
+        if (!statSync(skillDir).isDirectory())
+            continue;
+        const kb = getDirSize(skillDir) / 1024;
+        skills.push({ name: entry, kb });
+    }
+    if (skills.length === 0) {
+        return { area: "Top skills by size", status: "good", message: "No skills installed" };
+    }
+    skills.sort((a, b) => b.kb - a.kb);
+    const totalKB = skills.reduce((s, sk) => s + sk.kb, 0);
+    const totalMB = totalKB / 1024;
+    const top5 = skills
+        .slice(0, 5)
+        .map((s) => `${s.name} (${s.kb.toFixed(0)} KB)`)
+        .join(", ");
+    if (totalMB > 3) {
+        return {
+            area: "Top skills by size",
+            status: "warn",
+            message: `${skills.length} skills, ${totalMB.toFixed(1)} MB total. Top 5: ${top5}`,
+            action: "Review large skills with 'arcana list --installed'. Uninstall unused ones.",
+        };
+    }
+    if (totalMB > 1.5) {
+        return {
+            area: "Top skills by size",
+            status: "suggest",
+            message: `${skills.length} skills, ${totalMB.toFixed(1)} MB total. Top 5: ${top5}`,
+            action: "Consider removing rarely used skills to save context tokens",
+        };
+    }
+    return {
+        area: "Top skills by size",
+        status: "good",
+        message: `${skills.length} skills, ${totalMB.toFixed(1)} MB total. Top 5: ${top5}`,
+    };
+}
+export async function optimizeCommand(opts) {
+    if (!opts.json) {
+        banner();
+        console.log(ui.bold("  Claude Code Optimization Report\n"));
+    }
+    const recommendations = [
+        checkAutocompact(),
+        checkEffortLevel(),
+        checkNonEssentialCalls(),
+        checkPreCompactHook(),
+        checkSkillTokenBudget(),
+        checkMemorySize(),
+        checkAgentBloat(),
+        checkDiskHealth(),
+        checkLargestSkills(),
+    ];
+    if (opts.json) {
+        console.log(JSON.stringify({ recommendations }, null, 2));
+        return;
+    }
+    for (const rec of recommendations) {
+        const icon = rec.status === "good" ? ui.success("[OK]") : rec.status === "suggest" ? ui.cyan("[>>]") : ui.warn("[!!]");
+        console.log(`  ${icon} ${ui.bold(rec.area)}: ${rec.message}`);
+        if (rec.action) {
+            console.log(ui.dim(`      ${rec.action}`));
+        }
+    }
+    const actionable = recommendations.filter((r) => r.status !== "good");
+    console.log();
+    if (actionable.length === 0) {
+        console.log(ui.success("  Your setup is well optimized."));
+    }
+    else {
+        console.log(ui.dim(`  ${actionable.length} suggestion${actionable.length > 1 ? "s" : ""} to improve token usage and performance.`));
+    }
+    console.log();
+}

package/dist/commands/outdated.d.ts

@@ -0,0 +1,4 @@
+export declare function outdatedCommand(opts: {
+    provider?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/outdated.js

@@ -0,0 +1,159 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import semver from "semver";
+import { getInstallDir, readSkillMeta } from "../utils/fs.js";
+import { getProvider, getProviders } from "../registry.js";
+import { loadConfig } from "../utils/config.js";
+function listInstalledSkills(installDir) {
+    if (!existsSync(installDir))
+        return [];
+    let entries;
+    try {
+        entries = readdirSync(installDir);
+    }
+    catch {
+        return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+        const fullPath = join(installDir, entry);
+        try {
+            const stat = statSync(fullPath);
+            if (stat.isDirectory() && existsSync(join(fullPath, "SKILL.md"))) {
+                results.push(entry);
+            }
+        }
+        catch {
+            // skip unreadable
+        }
+    }
+    return results;
+}
+export async function outdatedCommand(opts) {
+    const installDir = getInstallDir();
+    const skills = listInstalledSkills(installDir);
+    if (skills.length === 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({ outdated: [], upToDate: 0, total: 0 }));
+        }
+        else {
+            console.log("No skills installed.");
+        }
+        process.exit(0);
+    }
+    const providerName = opts.provider ?? loadConfig().defaultProvider;
+    const providers = opts.provider ? [getProvider(providerName)] : getProviders();
+    if (providers.length === 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({
+                error: "No providers configured",
+                outdated: [],
+                upToDate: 0,
+                total: 0,
+            }));
+        }
+        else {
+            console.error("No providers configured. Run: arcana providers --add owner/repo");
+        }
+        process.exit(0);
+    }
+    const outdated = [];
+    let upToDate = 0;
+    let checked = 0;
+    for (const skillName of skills) {
+        const meta = readSkillMeta(skillName);
+        const localVersion = meta?.version ?? "0.0.0";
+        const preferredSource = meta?.source;
+        // Try the provider that installed this skill first, then fall back to others
+        const orderedProviders = [...providers];
+        if (preferredSource) {
+            const idx = orderedProviders.findIndex((p) => p.name === preferredSource);
+            if (idx > 0) {
+                const [pref] = orderedProviders.splice(idx, 1);
+                orderedProviders.unshift(pref);
+            }
+        }
+        let found = false;
+        for (const provider of orderedProviders) {
+            try {
+                const remoteInfo = await provider.info(skillName);
+                if (!remoteInfo)
+                    continue;
+                const remoteVersion = remoteInfo.version;
+                const coercedRemote = semver.valid(semver.coerce(remoteVersion)) ?? "0.0.0";
+                const coercedLocal = semver.valid(semver.coerce(localVersion)) ?? "0.0.0";
+                if (semver.gt(coercedRemote, coercedLocal)) {
+                    outdated.push({
+                        name: skillName,
+                        current: localVersion,
+                        available: remoteVersion,
+                        source: provider.name,
+                    });
+                }
+                else {
+                    upToDate++;
+                }
+                found = true;
+                checked++;
+                break;
+            }
+            catch {
+                // try next provider
+            }
+        }
+        if (!found) {
+            // Could not check this skill, count it as up-to-date for totals
+            upToDate++;
+            checked++;
+        }
+    }
+    const result = {
+        outdated,
+        upToDate,
+        total: checked,
+    };
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        process.exit(0);
+    }
+    // Console output: aligned table
+    console.log(`Checked ${result.total} installed skills.`);
+    console.log();
+    if (outdated.length === 0) {
+        console.log("All skills are up to date.");
+        process.exit(0);
+    }
+    // Calculate column widths
+    const nameWidth = Math.max(4, ...outdated.map((e) => e.name.length));
+    const currentWidth = Math.max(7, ...outdated.map((e) => e.current.length));
+    const availableWidth = Math.max(9, ...outdated.map((e) => e.available.length));
+    const sourceWidth = Math.max(6, ...outdated.map((e) => e.source.length));
+    const header = "Name".padEnd(nameWidth) +
+        "  " +
+        "Current".padEnd(currentWidth) +
+        "  " +
+        "Available".padEnd(availableWidth) +
+        "  " +
+        "Source".padEnd(sourceWidth);
+    const separator = "-".repeat(nameWidth) +
+        "  " +
+        "-".repeat(currentWidth) +
+        "  " +
+        "-".repeat(availableWidth) +
+        "  " +
+        "-".repeat(sourceWidth);
+    console.log(header);
+    console.log(separator);
+    for (const entry of outdated) {
+        console.log(entry.name.padEnd(nameWidth) +
+            "  " +
+            entry.current.padEnd(currentWidth) +
+            "  " +
+            entry.available.padEnd(availableWidth) +
+            "  " +
+            entry.source.padEnd(sourceWidth));
+    }
+    console.log();
+    console.log(`${outdated.length} outdated, ${upToDate} up to date, ${result.total} total`);
+    process.exit(0);
+}

package/dist/commands/profile.d.ts

@@ -0,0 +1,3 @@
+export declare function profileCommand(action: string | undefined, name: string | undefined, skills: string[], opts: {
+    json?: boolean;
+}): Promise<void>;