wizards 0.1.9

package/apps/runtime/dist/cli/exec.js

@@ -0,0 +1,45 @@
+import { spawn } from "node:child_process";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+/**
+ * Runs a command; what it prints goes line by line to `onLine` and into the log file.
+ * Never rejects for a command that fails: the caller reads `code`.
+ */
+export function runLogged(command, args, options = {}) {
+    const { logFile, onLine } = options;
+    if (logFile) {
+        mkdirSync(dirname(logFile), { recursive: true });
+        appendFileSync(logFile, `\n$ ${command} ${args.join(" ")}\n`);
+    }
+    return new Promise((resolve) => {
+        let tail = "";
+        let pending = "";
+        const take = (chunk) => {
+            const text = chunk.toString("utf8");
+            tail = (tail + text).slice(-4000);
+            if (logFile) {
+                appendFileSync(logFile, text);
+            }
+            pending += text;
+            const lines = pending.split(/\r?\n|\r/);
+            pending = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line.trim()) {
+                    onLine?.(line);
+                }
+            }
+        };
+        const child = spawn(command, args, {
+            env: options.env,
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        child.stdout.on("data", take);
+        child.stderr.on("data", take);
+        child.on("error", (error) => {
+            tail = `${tail}\n${error.message}`.trim();
+            resolve({ code: 127, tail });
+        });
+        child.on("close", (code) => resolve({ code: code ?? 1, tail: tail.trim() }));
+    });
+}

package/apps/runtime/dist/cli/home.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Where a local install lives: `~/.engenty/wizards`, inside the folder the engenty framework
+ * keeps its own install in. `ENGENTY_HOME` moves both.
+ */
+export function wizardsHome(env = process.env) {
+    const base = env.ENGENTY_HOME?.trim() || join(homedir(), ".engenty");
+    return join(resolve(base), "wizards");
+}
+export function layout(home = wizardsHome()) {
+    return {
+        home,
+        data: join(home, "data"),
+        logs: join(home, "logs"),
+        envFile: join(home, ".env"),
+        installFile: join(home, "install.json"),
+        runtime: join(home, "runtime"),
+        tools: join(home, "tools"),
+        clients: join(home, "clients"),
+        bin: join(home, "bin"),
+    };
+}
+/** The folder this code was installed to: it holds `apps/`, `plugin/` and package.json. */
+export const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../../..");
+export function packageVersion() {
+    try {
+        return JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8")).version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+/** How this copy got here: by install.sh into the home folder, or by npm/npx or a checkout. */
+export function installedByScript(paths = layout()) {
+    try {
+        // Node names this file by its real path; the home folder may be reached through a link.
+        return packageRoot.startsWith(realpathSync(paths.runtime) + sep);
+    }
+    catch {
+        return false;
+    }
+}
+/** This copy is a checkout of the repository, run with `pnpm wizards`. */
+export function isCheckout() {
+    return existsSync(join(packageRoot, "pnpm-workspace.yaml"));
+}
+export function readInstallNote(paths = layout()) {
+    try {
+        return JSON.parse(readFileSync(paths.installFile, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeInstallNote(note, paths = layout()) {
+    writeFileSync(paths.installFile, `${JSON.stringify(note, null, 2)}\n`);
+}
+/** `KEY=value` lines of the install's `.env`, the way the runtime reads them. */
+export function readEnvFile(file) {
+    const out = {};
+    if (!existsSync(file)) {
+        return out;
+    }
+    for (const line of readFileSync(file, "utf8").split("\n")) {
+        const match = line.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*)\s*$/);
+        if (match) {
+            out[match[1]] = match[2].replace(/^(['"])(.*)\1$/, "$2");
+        }
+    }
+    return out;
+}

package/apps/runtime/dist/cli/machine.js

@@ -0,0 +1,145 @@
+import { execFile } from "node:child_process";
+import { accessSync, constants, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import { promisify } from "node:util";
+import { runtimePath } from "./environment.js";
+const run = promisify(execFile);
+/** The AI clients the runtime can think with, in the order its own setup offers them. */
+export const CLIENTS = [
+    {
+        id: "codex",
+        name: "Codex",
+        bin: "codex",
+        account: "ChatGPT",
+        install: { kind: "npm", pkg: "@openai/codex" },
+        app: "ChatGPT",
+    },
+    {
+        id: "claude",
+        name: "Claude Code",
+        bin: "claude",
+        account: "Claude",
+        install: { kind: "script", url: "https://claude.ai/install.sh" },
+        app: "Claude",
+    },
+    {
+        id: "gemini",
+        name: "Gemini CLI",
+        bin: "gemini",
+        account: "Google",
+        install: { kind: "npm", pkg: "@google/gemini-cli" },
+    },
+    {
+        id: "cursor",
+        name: "Cursor Agent",
+        bin: "cursor-agent",
+        account: "Cursor",
+        install: { kind: "script", url: "https://cursor.com/install" },
+        app: "Cursor",
+    },
+];
+/** The client's desktop app, when it is on this Mac: its name, e.g. "Claude". */
+export function vendorApp(client, roots = ["/Applications", join(homedir(), "Applications")]) {
+    if (process.platform !== "darwin" || !client.app) {
+        return null;
+    }
+    const app = client.app;
+    return roots.some((root) => existsSync(join(root, `${app}.app`))) ? app : null;
+}
+/**
+ * The client the setup suggests among those not installed: the one whose app is on this Mac —
+ * its subscription is most likely already paid for — else the first.
+ */
+export function suggestedClient(missing) {
+    return missing.find((state) => vendorApp(state.client)) ?? missing[0] ?? null;
+}
+/** The first file of that name on a PATH that may be run. */
+export function findOnPath(name, path) {
+    for (const dir of path.split(delimiter)) {
+        if (!dir) {
+            continue;
+        }
+        const file = join(dir, name);
+        try {
+            accessSync(file, constants.X_OK);
+            return file;
+        }
+        catch {
+            // not here
+        }
+    }
+    return null;
+}
+/** What a command prints for `--version`: its last word that looks like one. */
+async function versionOf(file, path) {
+    try {
+        const { stdout } = await run(file, ["--version"], {
+            timeout: 10_000,
+            env: { ...process.env, PATH: path, TERM: "dumb" },
+        });
+        const line = stdout.trim().split("\n").pop()?.trim() ?? "";
+        return line.match(/\d+\.\d+[\w.+-]*/)?.[0] ?? (line || null);
+    }
+    catch {
+        return null;
+    }
+}
+export async function detectClients(paths) {
+    const path = runtimePath(paths, process.env);
+    return Promise.all(CLIENTS.map(async (client) => {
+        const file = findOnPath(client.bin, path);
+        // A file that does not answer `--version` is not a client we can run.
+        const version = file ? await versionOf(file, path) : null;
+        return { client, path: version ? file : null, version };
+    }));
+}
+/** The browser the runtime renders PDF and PNG with. */
+export function findChrome(env = process.env) {
+    if (env.CHROME_PATH) {
+        return existsSync(env.CHROME_PATH) ? env.CHROME_PATH : null;
+    }
+    if (process.platform === "darwin") {
+        const apps = [
+            "Google Chrome.app/Contents/MacOS/Google Chrome",
+            "Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+            "Chromium.app/Contents/MacOS/Chromium",
+            "Brave Browser.app/Contents/MacOS/Brave Browser",
+        ];
+        const roots = ["/Applications", join(homedir(), "Applications")];
+        for (const app of apps) {
+            for (const root of roots) {
+                if (existsSync(join(root, app))) {
+                    return join(root, app);
+                }
+            }
+        }
+        return null;
+    }
+    for (const name of ["google-chrome", "chromium", "chromium-browser", "microsoft-edge"]) {
+        const file = findOnPath(name, env.PATH ?? "");
+        if (file) {
+            return file;
+        }
+    }
+    return null;
+}
+export async function findFfmpeg(env = process.env) {
+    const path = env.PATH ?? "";
+    const file = env.FFMPEG_PATH || findOnPath("ffmpeg", path);
+    if (!file) {
+        return { path: null, version: null };
+    }
+    try {
+        const { stdout } = await run(file, ["-version"], { timeout: 10_000 });
+        return { path: file, version: stdout.match(/ffmpeg version (\S+)/)?.[1] ?? null };
+    }
+    catch {
+        return { path: null, version: null };
+    }
+}
+/** Node 24.11 or newer: what the runtime is built for. */
+export function nodeIsCurrent(version = process.versions.node) {
+    const [major, minor] = version.split(".").map(Number);
+    return major > 24 || (major === 24 && minor >= 11);
+}

package/apps/runtime/dist/cli/main.js

@@ -0,0 +1,125 @@
+import { layout, packageVersion, readInstallNote } from "./home.js";
+import { CLIENTS, nodeIsCurrent } from "./machine.js";
+import { command, setup } from "./setup.js";
+import { open, start } from "./start.js";
+import { autostart, status, stop } from "./status.js";
+import { update } from "./update.js";
+const HELP = `engenty wizards ${packageVersion()}
+
+  ${command()} [start]    start it and open the studio; the first time, the setup runs first
+  ${command()} setup      guided setup: an AI client to think with, ffmpeg, start at login
+  ${command()} open       let this browser into the running studio (--print: only show the link)
+  ${command()} status     what is installed and what runs
+  ${command()} doctor     status, and what is wrong
+  ${command()} stop       stop it; the data is kept
+  ${command()} update     the newest version
+  ${command()} autostart  start it at login: on, off (macOS: a LaunchAgent; Linux: a systemd service)
+
+  --yes, -y          ask nothing and install nothing optional
+  --client <name>    install this AI client without asking: ${CLIENTS.map((c) => c.id).join(", ")}
+  --no-open          start without opening the browser
+  --version, --help
+
+  Everything lives in ~/.engenty/wizards (ENGENTY_HOME moves it); settings go into its .env.
+`;
+function parse(argv) {
+    const args = {
+        command: "",
+        value: "",
+        yes: false,
+        open: true,
+        print: false,
+        clients: [],
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--yes" || arg === "-y") {
+            args.yes = true;
+        }
+        else if (arg === "--no-open") {
+            args.open = false;
+        }
+        else if (arg === "--print") {
+            args.print = true;
+        }
+        else if (arg === "--client") {
+            const id = argv[++i];
+            if (!CLIENTS.some((client) => client.id === id)) {
+                return `--client takes one of: ${CLIENTS.map((c) => c.id).join(", ")}`;
+            }
+            args.clients.push(id);
+        }
+        else if (arg === "--help" || arg === "-h") {
+            args.command = "help";
+        }
+        else if (arg === "--version" || arg === "-v") {
+            args.command = "version";
+        }
+        else if (arg.startsWith("-")) {
+            return `Unknown option ${arg}.`;
+        }
+        else if (args.command === "autostart" && !args.value) {
+            args.value = arg;
+        }
+        else if (args.command) {
+            return `Unexpected argument ${arg}.`;
+        }
+        else {
+            args.command = arg;
+        }
+    }
+    args.command ||= "start";
+    return args;
+}
+async function main(argv) {
+    const args = parse(argv);
+    if (typeof args === "string") {
+        console.error(`${args}\n\n${HELP}`);
+        return 2;
+    }
+    const paths = layout();
+    const setupOptions = { yes: args.yes, clients: args.clients };
+    switch (args.command) {
+        case "help":
+            console.log(HELP);
+            return 0;
+        case "version":
+            console.log(packageVersion());
+            return 0;
+        case "start": {
+            // The first start on a terminal begins with the setup.
+            const first = !readInstallNote(paths).setupAt;
+            if (first && !args.yes && process.stdin.isTTY && process.stdout.isTTY) {
+                const next = await setup(paths, setupOptions);
+                if (next !== "start") {
+                    return next === null ? 130 : 0;
+                }
+            }
+            return start(paths, { open: args.open });
+        }
+        case "setup": {
+            const next = await setup(paths, setupOptions);
+            return next === "start" ? start(paths, { open: args.open }) : next === null ? 130 : 0;
+        }
+        case "open":
+            return open(paths, args.print);
+        case "status":
+            return status(paths, false);
+        case "doctor":
+            return status(paths, true);
+        case "stop":
+            return stop(paths);
+        case "update":
+            return update(paths);
+        case "autostart":
+            return autostart(paths, args.value);
+        default:
+            console.error(`Unknown command ${args.command}.\n\n${HELP}`);
+            return 2;
+    }
+}
+if (!nodeIsCurrent()) {
+    console.error(`engenty wizards needs Node.js 24.11 or newer; this is ${process.version}.`);
+    process.exit(1);
+}
+process.exitCode = await main(process.argv.slice(2));

package/apps/runtime/dist/cli/setup.js

@@ -0,0 +1,273 @@
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import * as p from "@clack/prompts";
+import { autostartState, setAutostart } from "./autostart.js";
+import { installClient, installCommand } from "./clients.js";
+import { runLogged } from "./exec.js";
+import { installedByScript, isCheckout, packageVersion, readInstallNote, writeInstallNote, } from "./home.js";
+import { CLIENTS, detectClients, findChrome, findFfmpeg, findOnPath, suggestedClient, vendorApp, } from "./machine.js";
+import { badge, cyan, dim, tilde } from "./ui.js";
+/** The studio as an app of its own: Chrome (or Edge) installs it from the page. */
+const CHROME_APP = "Tip: in Chrome or Edge the studio installs as an app, in a window of its own with its own icon. The studio offers it at the top; or use the install icon in the address bar.";
+/** How this install is started, as the person types it. */
+export const command = () => installedByScript() ? "wizards" : isCheckout() ? "pnpm wizards" : "npx wizards";
+/** A spinner on a terminal; where nobody watches, only what came of it. */
+function busy(message) {
+    if (!process.stdout.isTTY) {
+        return { stop: (text) => p.log.step(text), fail: (text) => p.log.warn(text) };
+    }
+    const spinner = p.spinner();
+    spinner.start(message);
+    return {
+        stop: (text) => spinner.stop(text),
+        fail: (text) => spinner.error(text),
+    };
+}
+function cancelled(value) {
+    if (p.isCancel(value)) {
+        p.cancel(`Setup stopped. Run it again with \`${command()} setup\`.`);
+        return true;
+    }
+    return false;
+}
+async function install(client, paths) {
+    const task = p.taskLog({ title: `Installing ${client.name}`, limit: 6 });
+    task.message(dim(installCommand(client, paths)));
+    const { code, tail } = await installClient(client, paths, (line) => task.message(line));
+    const installed = (await detectClients(paths)).find((state) => state.client.id === client.id);
+    if (code === 0 && installed?.path) {
+        task.success(`${client.name} ${installed.version ?? ""} installed`.trim());
+        return true;
+    }
+    task.error(`${client.name} was not installed${code === 0 ? ": its command is not on the PATH" : ""}. ${tail.split("\n").pop() ?? ""}`);
+    return false;
+}
+async function clientsStep(paths, options, interactive) {
+    const spinner = busy("Looking for AI clients on this machine");
+    const found = await detectClients(paths);
+    const installed = found.filter((state) => state.path);
+    const missing = found.filter((state) => !state.path);
+    spinner.stop(installed.length
+        ? `Thinks with: ${installed.map((s) => `${s.client.name} ${s.version}`).join(", ")}`
+        : "No AI client on this machine yet");
+    if (!installed.length) {
+        p.log.message(dim("engenty wizards thinks with one, on the subscription you already have."));
+    }
+    let wanted = missing.filter((s) => options.clients.includes(s.client.id));
+    if (interactive && missing.length && !wanted.length) {
+        const suggested = suggestedClient(missing);
+        // A client whose app is on this Mac comes first: its subscription is most likely paid for.
+        const offered = [...missing].sort((a, b) => Number(!vendorApp(a.client)) - Number(!vendorApp(b.client)));
+        const answer = await p.multiselect({
+            message: installed.length
+                ? "Install another AI client? (space to pick, enter to go on)"
+                : "Which one shall I install?",
+            options: offered.map(({ client }) => {
+                const app = vendorApp(client);
+                return {
+                    value: client.id,
+                    label: client.name,
+                    hint: [
+                        `${client.account} subscription`,
+                        app ? `the ${app} app is on this Mac` : "",
+                        !installed.length && client.id === suggested?.client.id ? "recommended" : "",
+                    ]
+                        .filter(Boolean)
+                        .join(", "),
+                };
+            }),
+            initialValues: installed.length || !suggested ? [] : [suggested.client.id],
+            required: false,
+        });
+        if (cancelled(answer)) {
+            return "cancelled";
+        }
+        wanted = missing.filter((s) => answer.includes(s.client.id));
+    }
+    let any = installed.length > 0;
+    for (const { client } of wanted) {
+        any = (await install(client, paths)) || any;
+    }
+    if (any) {
+        p.log.info("You sign the client in on the first page of the studio.");
+    }
+    else {
+        p.log.warn(`No AI client yet: the first page of the studio installs one, or takes an API key (Vercel AI Gateway, OpenAI, Anthropic) or a local model (Ollama).\n${dim(`Or here, later: ${CLIENTS.map((c) => c.name).join(", ")} with \`${command()} setup\`.`)}`);
+    }
+    return any;
+}
+async function toolsStep(interactive) {
+    const chrome = findChrome();
+    if (chrome) {
+        p.log.success(`Browser for PDF and PNG: ${dim(tilde(chrome))}`);
+    }
+    else {
+        p.log.warn("No Chrome, Edge or Chromium: PDF and PNG exports and browser steps need one.\nhttps://www.google.com/chrome");
+    }
+    const ffmpeg = await findFfmpeg();
+    if (ffmpeg.path) {
+        p.log.success(`ffmpeg ${ffmpeg.version ?? ""} for videos`.replace("  ", " "));
+        return;
+    }
+    const brew = findOnPath("brew", process.env.PATH ?? "");
+    if (!interactive || !brew) {
+        p.log.warn(`No ffmpeg: MP4 videos of animated widgets need it.${brew ? `\n${dim("brew install ffmpeg")}` : ""}`);
+        return;
+    }
+    const answer = await p.confirm({
+        message: "No ffmpeg (for MP4 videos of animated widgets). Install it with Homebrew?",
+        initialValue: false,
+    });
+    if (cancelled(answer)) {
+        return "cancelled";
+    }
+    if (answer) {
+        const task = p.taskLog({ title: "Installing ffmpeg", limit: 6 });
+        const { code, tail } = await runLogged(brew, ["install", "ffmpeg"], {
+            onLine: (line) => task.message(line),
+        });
+        if (code === 0) {
+            task.success("ffmpeg installed");
+        }
+        else {
+            task.error(`ffmpeg was not installed. ${tail.split("\n").pop() ?? ""}`);
+        }
+    }
+}
+/**
+ * Starting at login: on a Mac a LaunchAgent starts the runtime, on Linux a systemd user
+ * service does. Asked, never assumed; `autostart off` undoes it.
+ */
+async function autostartStep(paths, interactive) {
+    const state = await autostartState(paths);
+    if ("unavailable" in state) {
+        return;
+    }
+    if (state.on) {
+        p.log.success(`Starts at login: ${dim(state.how)}`);
+        return;
+    }
+    if (!interactive) {
+        p.log.info(dim(`To start it at login: \`${command()} autostart on\``));
+        return;
+    }
+    const answer = await p.confirm({
+        message: "Start engenty wizards when you log in? It keeps running in the background, so links and AI clients always reach it.",
+        initialValue: true,
+    });
+    if (cancelled(answer)) {
+        return "cancelled";
+    }
+    if (!answer) {
+        p.log.info(dim(`Later: \`${command()} autostart on\``));
+        return;
+    }
+    try {
+        const after = await setAutostart(paths, true);
+        if ("on" in after && after.on) {
+            p.log.success(`Starts at login: ${dim(after.how)}`);
+        }
+        else {
+            p.log.warn("Starting at login could not be switched on.");
+        }
+    }
+    catch (error) {
+        p.log.warn(`Starting at login could not be switched on. ${error.message}`);
+    }
+}
+/** The line that puts `~/.local/bin` on the PATH, and the shell file it belongs in. */
+function pathLine() {
+    const shell = process.env.SHELL ?? "";
+    if (shell.endsWith("fish")) {
+        return {
+            file: join(homedir(), ".config/fish/config.fish"),
+            line: "fish_add_path ~/.local/bin",
+        };
+    }
+    const file = shell.endsWith("zsh")
+        ? ".zshrc"
+        : process.platform === "darwin"
+            ? ".bash_profile"
+            : ".bashrc";
+    return { file: join(homedir(), file), line: 'export PATH="$HOME/.local/bin:$PATH"' };
+}
+/** An install made by install.sh has its command in `~/.local/bin`: is that on the PATH? */
+async function pathStep(interactive) {
+    const local = join(homedir(), ".local", "bin");
+    if (!installedByScript() || (process.env.PATH ?? "").split(delimiter).includes(local)) {
+        return;
+    }
+    const { file, line } = pathLine();
+    if (existsSync(file) && readFileSync(file, "utf8").includes(".local/bin")) {
+        p.log.info(`Open a new terminal to use the \`wizards\` command.`);
+        return;
+    }
+    const hint = `Until then: ${tilde(join(local, "wizards"))}`;
+    if (!interactive) {
+        p.log.warn(`~/.local/bin is not on your PATH. Add to ${tilde(file)}:\n${line}\n${dim(hint)}`);
+        return;
+    }
+    const answer = await p.confirm({
+        message: `The \`wizards\` command is in ~/.local/bin, which is not on your PATH. Add it in ${tilde(file)}?`,
+        initialValue: true,
+    });
+    if (cancelled(answer)) {
+        return "cancelled";
+    }
+    if (answer) {
+        appendFileSync(file, `\n# engenty wizards\n${line}\n`);
+        p.log.success(`Added to ${tilde(file)}. It works in a new terminal.\n${dim(hint)}`);
+    }
+    else {
+        p.log.info(hint);
+    }
+}
+/**
+ * The guided setup: what this machine has, what is missing, and what to install — an AI client
+ * to think with, ffmpeg, starting at login. Returns what to do next, or null when it was stopped.
+ */
+export async function setup(paths, options) {
+    const interactive = !options.yes && Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const version = packageVersion();
+    p.intro(`${badge("engenty wizards")} ${dim(version)}`);
+    p.log.message([
+        `Install  ${tilde(paths.home)}${installedByScript() ? "" : dim(`  (data; the code runs from ${isCheckout() ? "this checkout" : "npm"})`)}`,
+        `Node     ${process.version}  ${dim(tilde(process.execPath))}`,
+    ].join("\n"));
+    if ((await clientsStep(paths, options, interactive)) === "cancelled") {
+        return null;
+    }
+    if ((await toolsStep(interactive)) === "cancelled") {
+        return null;
+    }
+    if ((await autostartStep(paths, interactive)) === "cancelled") {
+        return null;
+    }
+    if ((await pathStep(interactive)) === "cancelled") {
+        return null;
+    }
+    writeInstallNote({ ...readInstallNote(paths), setupAt: new Date().toISOString(), version }, paths);
+    p.log.info(CHROME_APP);
+    if (!interactive) {
+        p.outro(`Start it with ${cyan(command())}`);
+        return "later";
+    }
+    const next = await p.select({
+        message: "All set. What next?",
+        options: [
+            { value: "start", label: "Start it here", hint: "the studio opens in your browser" },
+            { value: "later", label: "Not now" },
+        ],
+    });
+    if (cancelled(next)) {
+        return null;
+    }
+    if (next === "later") {
+        p.outro(`Start it with ${cyan(command())}`);
+    }
+    else {
+        p.outro("Starting engenty wizards");
+    }
+    return next;
+}