@giovannijecha/jecode 0.1.5-rc.2

package/dist/credentials.js

@@ -0,0 +1,124 @@
+// Where an API key comes from, and where one goes when the user types it in.
+//
+// Three layers, looked at in this order: the environment, then whatever this
+// session was handed, then the saved file. The environment winning is the
+// load-bearing part — a key exported in the shell is the one the user is
+// looking at, and a stale saved key quietly overriding it is the worst kind of
+// bug to be on the wrong side of.
+//
+// The file lives under ~/.jecode and never in this repo. A
+// secret in the working tree is one `git add -A` from being published, which
+// is why "not in the repo" is a rule and not a preference.
+import { chmod, mkdir } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import * as path from "node:path";
+import { atomicWrite } from "./atomic.js";
+import { legacyUserDataPath, userDataLabel, userDataPath } from "./user-data.js";
+/** Keys this session was given but not asked to keep. Dies with the window. */
+const held = new Map();
+/** The saved file, read once. `undefined` until the first look at it. */
+let saved;
+export function keyFor(name) {
+    return use(process.env[name]) ?? use(held.get(name)) ?? use(fromDisk()[name]);
+}
+export function credentialSource(name) {
+    if (use(process.env[name]) !== undefined)
+        return "environment";
+    if (use(held.get(name)) !== undefined)
+        return "session";
+    return use(fromDisk()[name]) === undefined ? undefined : "saved";
+}
+/** Values that must never survive in shell output, regardless of their source. */
+export function credentialValues() {
+    const stored = fromDisk();
+    const names = new Set([...held.keys(), ...Object.keys(stored)]);
+    const values = new Set([...held.values(), ...Object.values(stored)]);
+    for (const name of names) {
+        const environment = use(process.env[name]);
+        if (environment !== undefined)
+            values.add(environment);
+    }
+    return [...values].filter((value) => use(value) !== undefined);
+}
+export function hasSaved(name) {
+    return use(fromDisk()[name]) !== undefined;
+}
+/** Take a key for this session only. Nothing is written anywhere. */
+export function hold(name, value) {
+    held.set(name, value);
+}
+/**
+ * Take a key and write it down, returning the path it went to.
+ *
+ * Owner-only permissions on a directory that did not exist a moment ago: the
+ * mode is set at creation rather than fixed afterwards, because between the
+ * two there is a window where the file is readable and the key is in it.
+ * Windows ignores the mode and relies on the profile directory's own ACL.
+ */
+export async function keep(name, value) {
+    const file = storePath();
+    const all = { ...fromDisk(), [name]: value };
+    await persist(file, all);
+    hold(name, value);
+    saved = all;
+    return file;
+}
+/** Remove only the saved copy. An environment or session value is untouched. */
+export async function forgetSaved(name) {
+    const all = { ...fromDisk() };
+    if (use(all[name]) === undefined)
+        return false;
+    delete all[name];
+    const file = storePath();
+    await persist(file, all);
+    saved = all;
+    return true;
+}
+export function storePath() {
+    return userDataPath("credentials.json");
+}
+/**
+ * The store path, written the way the user would write it.
+ *
+ * This label is compact enough for both menu rows and transient feedback. The
+ * canonical path remains discoverable without pushing useful copy off-screen.
+ */
+export function storeLabel() {
+    return userDataLabel("credentials.json");
+}
+/** Forget what was read, so the next look goes back to disk. For tests. */
+export function reload() {
+    saved = undefined;
+    held.clear();
+}
+function fromDisk() {
+    if (saved !== undefined)
+        return saved;
+    const current = readStore(storePath());
+    const legacy = legacyUserDataPath("credentials.json");
+    saved = current ?? (legacy === undefined ? undefined : readStore(legacy)) ?? {};
+    return saved;
+}
+function readStore(file) {
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        // Anything that is not a string is not a key, whatever the file says.
+        return Object.fromEntries(Object.entries(parsed).filter((entry) => typeof entry[1] === "string"));
+    }
+    catch (error) {
+        // Only a missing canonical file falls through to the legacy location. A
+        // malformed new store must not resurrect an older credential silently.
+        return error.code === "ENOENT" ? undefined : {};
+    }
+}
+async function persist(file, values) {
+    const directory = path.dirname(file);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32")
+        await chmod(directory, 0o700);
+    await atomicWrite(file, `${JSON.stringify(values, null, 2)}\n`, { mode: 0o600 });
+}
+/** An empty variable is an unset variable — an exported "" is not a key. */
+function use(value) {
+    return value === undefined || value === "" ? undefined : value;
+}

package/dist/main.js

@@ -0,0 +1,7 @@
+// Process entry point. The testable bootstrap lives in start.ts.
+import { start } from "./start.js";
+import { terminalText } from "./ui/terminal-text.js";
+start().catch((error) => {
+    process.stderr.write(`jecode: ${terminalText(error.message)}\n`);
+    process.exitCode = 1;
+});

package/dist/ollama-settings-command.js

@@ -0,0 +1,75 @@
+// Ollama connection choices inside the persistent settings hub.
+import { askForKey } from "./credential-commands.js";
+import { keyFor } from "./credentials.js";
+import { of } from "./tui/editor.js";
+import { heading } from "./tui/picker.js";
+import { OLLAMA_CLOUD_HOST, OLLAMA_LOCAL_HOST, parseOllamaEndpoint, } from "./providers/ollama-endpoint.js";
+import { configureOllama, ollamaConnection } from "./providers/ollama.js";
+const KEY = "OLLAMA_API_KEY";
+export function ollamaConnectionHint() {
+    const connection = ollamaConnection();
+    const origin = new URL(connection.baseUrl).host;
+    const automatic = connection.inferred ? " · automatic" : "";
+    if (connection.kind === "local")
+        return `local · this computer${automatic}`;
+    return `${connection.kind} · ${origin}${automatic}`;
+}
+export async function ollamaConnectionSetting(session, host, persist) {
+    if (host.choose === undefined)
+        return;
+    const current = ollamaConnection();
+    const index = await host.choose({
+        title: heading("Ollama connection", "where Ollama requests run", session.palette),
+        right: "↑↓ enter · esc back",
+        options: [
+            { label: "cloud", hint: "ollama.com · API key" },
+            { label: "local", hint: "this computer · no API key" },
+            { label: "custom", hint: "HTTPS or loopback endpoint" },
+        ],
+        index: current.kind === "cloud" ? 0 : current.kind === "local" ? 1 : 2,
+    });
+    if (index === undefined)
+        return;
+    let nextHost;
+    if (index === 0)
+        nextHost = OLLAMA_CLOUD_HOST;
+    else if (index === 1)
+        nextHost = OLLAMA_LOCAL_HOST;
+    else {
+        const custom = await customEndpoint(session, host, current.kind === "custom" ? current.baseUrl : "https://");
+        if (custom === undefined)
+            return;
+        nextHost = custom;
+    }
+    const endpoint = parseOllamaEndpoint(nextHost);
+    if (!endpoint.loopback && keyFor(KEY) === undefined) {
+        const accepted = await askForKey(KEY, host, session.palette);
+        if (!accepted)
+            return;
+    }
+    if (!(await persist({ ollamaHost: endpoint.baseUrl })))
+        return;
+    configureOllama(endpoint.baseUrl);
+    session.config.ollamaHost = endpoint.baseUrl;
+}
+async function customEndpoint(session, host, initial) {
+    if (host.type === undefined)
+        return undefined;
+    const field = {
+        title: heading("Ollama endpoint", "HTTPS or exact loopback URL", session.palette),
+        right: "enter save · esc back",
+        editor: of(initial),
+        secret: false,
+        note: "Remote endpoints must use HTTPS. API keys are stored separately.",
+    };
+    const value = await host.type(field);
+    if (value === undefined)
+        return undefined;
+    try {
+        return parseOllamaEndpoint(value).baseUrl;
+    }
+    catch (error) {
+        host.emit({ kind: "notice", text: error.message, tone: "error" });
+        return undefined;
+    }
+}

package/dist/prompt.js

@@ -0,0 +1,29 @@
+// The system prompt. Its own module because it is content, not logic — it
+// gets rewritten far more often than the loop that carries it.
+export function systemPrompt(config) {
+    return [
+        "You are jecode, a coding agent working in a terminal alongside the user.",
+        "",
+        `Workspace root: ${config.root}`,
+        `Platform: ${process.platform}`,
+        "",
+        "How you work:",
+        "- Read before you write. Use find_files, search_text, read_file, and list_dir",
+        "  to ground yourself in the actual code rather than assuming what it contains.",
+        "- Prefer edit_file over write_file for existing files; write_file replaces",
+        "  the whole file and loses anything you did not reproduce.",
+        "- Every path you pass to a tool is relative to the workspace root, and you",
+        "  cannot reach outside it.",
+        "- Batch independent tool calls in one turn; the results come back together.",
+        "- After changing code, verify it — run the tests or the typechecker with",
+        "  run_command rather than declaring success untested.",
+        "- When a tool fails, read the error and correct the call. You get another turn.",
+        "",
+        "How you answer:",
+        "- Be concise and concrete. Lead with the result, skip the preamble.",
+        "- Say plainly what you did and what you did not do. If something is still",
+        "  broken or unverified, say so rather than papering over it.",
+        "- Ask the user when a decision is genuinely theirs; otherwise make the call",
+        "  and keep going.",
+    ].join("\n");
+}

package/dist/provider-commands.js

@@ -0,0 +1,236 @@
+// Provider, model, and setup command flows.
+import { heading } from "./tui/picker.js";
+import { PROVIDERS } from "./providers/index.js";
+import { readSettings } from "./settings.js";
+import { askForKey } from "./credential-commands.js";
+import { providerFailure } from "./provider-errors.js";
+/**
+ * The provider menu.
+ *
+ * Every provider is offered, including the ones that cannot run: the reason
+ * one is unusable — the variable it wants, by name — is worth more on screen
+ * than the row would be worth hidden. A blocked choice opens the same masked
+ * credential flow used by setup and settings, and cancellation leaves the old choice.
+ */
+export async function providersCommand(session, host, behavior = {}) {
+    const choose = chooser(host);
+    if (choose === undefined)
+        return false;
+    const options = PROVIDERS.map((provider) => ({
+        label: provider.id,
+        hint: provider.blocked() ?? "ready",
+    }));
+    const at = PROVIDERS.findIndex((provider) => provider.id === session.provider.id);
+    const index = await choose({
+        title: heading("provider", "where the next turn runs", session.palette),
+        right: "↑↓ enter",
+        options,
+        index: Math.max(0, at),
+    });
+    if (index === undefined)
+        return false;
+    const chosen = PROVIDERS[index];
+    if (chosen === undefined)
+        return false;
+    // Picking the provider already in use is not a no-op when it cannot run:
+    // it is how the user asks to fix the reason it cannot.
+    if (chosen.id === session.provider.id) {
+        const blocked = chosen.blocked();
+        if (blocked !== undefined) {
+            if (!isCredentialBlocker(chosen, blocked)) {
+                host.emit({ kind: "notice", text: blocked, tone: "error" });
+                return false;
+            }
+            await askForKey(chosen.keyVar, host, session.palette);
+            if (chosen.blocked() !== undefined)
+                return false;
+        }
+        return true;
+    }
+    // A provider that cannot run is worth one offer to fix it, here, rather
+    // than a note telling the user to leave and export something.
+    const blocked = chosen.blocked();
+    if (blocked !== undefined) {
+        if (!isCredentialBlocker(chosen, blocked)) {
+            host.emit({ kind: "notice", text: blocked, tone: "error" });
+            return false;
+        }
+        await askForKey(chosen.keyVar, host, session.palette);
+        const still = chosen.blocked();
+        if (still !== undefined) {
+            host.emit({
+                kind: "notice",
+                text: `${providerName(chosen.id)} still needs an API key · provider unchanged`,
+                tone: "warn",
+            });
+            return false;
+        }
+    }
+    const before = {
+        provider: session.provider,
+        model: session.model,
+        providerId: session.config.providerId,
+        configModel: session.config.model,
+    };
+    session.provider = chosen;
+    // The model belonged to the old provider. Carrying it across would send
+    // `claude-sonnet-5` to OpenAI and call the 404 a bug in the provider.
+    session.model = readSettings().models?.[chosen.id] ?? chosen.defaultModel;
+    session.config.providerId = chosen.id;
+    session.config.model = session.model;
+    if (behavior.save !== false) {
+        const saved = readSettings();
+        const models = { ...saved.models };
+        if (session.model !== "")
+            models[chosen.id] = session.model;
+        if (!(await saveDefaults(host, { provider: chosen.id, models }))) {
+            session.provider = before.provider;
+            session.model = before.model;
+            session.config.providerId = before.providerId;
+            session.config.model = before.configModel;
+            return false;
+        }
+    }
+    if (behavior.announce !== false) {
+        host.emit({
+            kind: "notice",
+            text: session.model === "" ? `${chosen.id} — pick a model with /models` : `${chosen.id} · ${session.model}`,
+            tone: "info",
+        });
+    }
+    return true;
+}
+/** The model menu, built from what the provider says it has right now. */
+export async function modelsCommand(session, host, behavior = {}) {
+    // Before the network, not after: asking a provider for a list nothing can
+    // be picked from is a request spent on a menu that will never open.
+    const choose = chooser(host);
+    if (choose === undefined)
+        return false;
+    const provider = session.provider;
+    // Offer the key rather than only naming what is missing: the user came here
+    // to pick a model, and "go and export a variable" is not an answer.
+    const blocked = provider.blocked();
+    if (blocked !== undefined) {
+        if (!isCredentialBlocker(provider, blocked)) {
+            host.emit({ kind: "notice", text: blocked, tone: "error" });
+            return false;
+        }
+        await askForKey(provider.keyVar, host, session.palette);
+        const still = provider.blocked();
+        if (still !== undefined) {
+            host.emit({
+                kind: "notice",
+                text: `${providerName(provider.id)} still needs an API key`,
+                tone: "warn",
+            });
+            return false;
+        }
+    }
+    host.status?.(`Asking ${provider.id}`);
+    let ids;
+    try {
+        ids = await provider.models(host.signal, (status) => host.status?.(status));
+    }
+    catch (error) {
+        host.emit({
+            kind: "notice",
+            text: providerFailure(provider, error, true),
+            tone: "error",
+        });
+        return false;
+    }
+    finally {
+        host.status?.(undefined);
+    }
+    if (ids.length === 0) {
+        host.emit({ kind: "notice", text: `${provider.id} offers no models`, tone: "warn" });
+        return false;
+    }
+    const index = await choose({
+        title: heading("model", provider.id, session.palette),
+        right: "↑↓ enter",
+        options: ids.map((id) => ({ label: id })),
+        searchable: true,
+        query: "",
+        index: Math.max(0, ids.indexOf(session.model)),
+    });
+    if (index === undefined)
+        return false;
+    const chosen = ids[index];
+    if (chosen === undefined)
+        return false;
+    const before = { model: session.model, configModel: session.config.model };
+    session.model = chosen;
+    session.config.model = chosen;
+    if (behavior.save !== false) {
+        const saved = readSettings();
+        const models = { ...saved.models, [provider.id]: chosen };
+        if (!(await saveDefaults(host, { models }))) {
+            session.model = before.model;
+            session.config.model = before.configModel;
+            return false;
+        }
+    }
+    if (behavior.announce !== false) {
+        host.emit({ kind: "notice", text: `${provider.id} · ${chosen}`, tone: "info" });
+    }
+    return true;
+}
+/** Make the provider selected by flags/environment usable without leaving the TUI. */
+export async function setupCommand(session, host) {
+    const blocked = session.provider.blocked();
+    if (blocked !== undefined) {
+        if (!isCredentialBlocker(session.provider, blocked)) {
+            host.emit({ kind: "notice", text: blocked, tone: "error" });
+            return;
+        }
+        const accepted = await askForKey(session.provider.keyVar, host, session.palette);
+        if (!accepted || session.provider.blocked() !== undefined) {
+            host.emit({
+                kind: "notice",
+                text: `${providerName(session.provider.id)} still needs an API key · /setup`,
+                tone: "warn",
+            });
+            return;
+        }
+    }
+    if (session.model === "") {
+        await modelsCommand(session, host);
+        return;
+    }
+    host.emit({
+        kind: "notice",
+        text: `${session.provider.id} · ${session.model} · ${session.provider.location?.() ?? "cloud"} · ready`,
+        tone: "info",
+    });
+}
+/** The way to put a menu up, or nothing — and the reason, already said. */
+function chooser(host) {
+    if (host.choose === undefined) {
+        host.emit({ kind: "notice", text: "that command needs the screen", tone: "warn" });
+    }
+    return host.choose;
+}
+function providerName(id) {
+    return id === "" ? "Provider" : `${id[0]?.toUpperCase() ?? ""}${id.slice(1)}`;
+}
+function isCredentialBlocker(provider, blocked) {
+    return blocked.startsWith(`${provider.keyVar} `);
+}
+async function saveDefaults(host, patch) {
+    if (host.saveSettings === undefined)
+        return true;
+    try {
+        await host.saveSettings(patch);
+        return true;
+    }
+    catch (error) {
+        host.emit({
+            kind: "notice",
+            text: `could not save settings · ${error.message}`,
+            tone: "error",
+        });
+        return false;
+    }
+}

package/dist/provider-errors.js

@@ -0,0 +1,10 @@
+// Actionable provider failures for user-facing command and turn surfaces.
+const CONNECTION_FAILURE = /network error calling|timed out waiting for response headers|response body was idle/i;
+export function providerFailure(provider, error, labelProvider = false) {
+    if (provider.id === "ollama" && CONNECTION_FAILURE.test(error.message)) {
+        return provider.location?.() === "local"
+            ? "Ollama is not reachable on this computer · start Ollama or choose cloud in /settings"
+            : "Ollama is not reachable · check its connection in /settings";
+    }
+    return labelProvider ? `${provider.id}: ${error.message}` : error.message;
+}

package/dist/providers/anthropic-stream.js

@@ -0,0 +1,111 @@
+// Reassembling an Anthropic response from its event stream.
+//
+// The stream never delivers a finished message — `message_stop` carries
+// nothing — so the blocks have to be rebuilt here, index by index, into
+// exactly the array a non-streamed response would have returned. That matters
+// beyond display: thinking blocks carry a signature and must be echoed back
+// byte-for-byte on the next request.
+import { addBounded, MAX_TOOL_ARGUMENT_CHARS } from "./stream-limits.js";
+export async function assembleAnthropic(events, onStream) {
+    const blocks = new Map();
+    const partialJson = new Map();
+    const sizes = { toolArguments: 0 };
+    let stopReason;
+    let stopDetails;
+    let usage;
+    for await (const raw of events) {
+        const event = raw;
+        switch (event.type) {
+            case "message_start":
+                usage = mergeUsage(usage, event.message?.usage);
+                break;
+            case "content_block_start": {
+                if (typeof event.index === "number" && event.content_block !== undefined) {
+                    blocks.set(event.index, { ...event.content_block });
+                }
+                break;
+            }
+            case "content_block_delta": {
+                if (typeof event.index !== "number")
+                    break;
+                applyDelta(blocks, partialJson, sizes, event.index, event.delta, onStream);
+                break;
+            }
+            case "content_block_stop": {
+                if (typeof event.index !== "number")
+                    break;
+                const pending = partialJson.get(event.index);
+                const block = blocks.get(event.index);
+                if (pending !== undefined && block !== undefined) {
+                    block.input = parseJsonObject(pending);
+                    partialJson.delete(event.index);
+                }
+                break;
+            }
+            case "message_delta": {
+                stopReason = event.delta?.stop_reason ?? stopReason;
+                stopDetails = event.delta?.stop_details ?? stopDetails;
+                usage = mergeUsage(usage, event.usage);
+                break;
+            }
+            case "error": {
+                throw new Error(`anthropic stream error: ${event.error?.message ?? "unspecified"}`);
+            }
+            default:
+                break; // message_start, ping, message_stop: nothing to accumulate
+        }
+    }
+    const content = [...blocks.entries()]
+        .sort(([a], [b]) => a - b)
+        .map(([, block]) => block);
+    return { content, stop_reason: stopReason, stop_details: stopDetails, usage };
+}
+function mergeUsage(before, after) {
+    return after === undefined ? before : { ...before, ...after };
+}
+function applyDelta(blocks, partialJson, sizes, index, delta, onStream) {
+    const block = blocks.get(index);
+    if (delta === undefined || block === undefined)
+        return;
+    switch (delta.type) {
+        case "text_delta":
+            if (typeof delta.text !== "string")
+                return;
+            block.text = `${block.text ?? ""}${delta.text}`;
+            onStream?.({ kind: "text", text: delta.text });
+            return;
+        case "thinking_delta":
+            if (typeof delta.thinking !== "string")
+                return;
+            block.thinking = `${block.thinking ?? ""}${delta.thinking}`;
+            onStream?.({ kind: "thinking", text: delta.thinking });
+            return;
+        case "signature_delta":
+            if (typeof delta.signature === "string")
+                block.signature = delta.signature;
+            return;
+        case "input_json_delta":
+            if (typeof delta.partial_json !== "string")
+                return;
+            sizes.toolArguments = addBounded(sizes.toolArguments, delta.partial_json.length, MAX_TOOL_ARGUMENT_CHARS, "streamed tool arguments");
+            partialJson.set(index, `${partialJson.get(index) ?? ""}${delta.partial_json}`);
+            return;
+        default:
+            return;
+    }
+}
+// Tool arguments arrive as a stream of JSON fragments. An empty accumulation
+// is a call with no arguments, not a malformed one.
+function parseJsonObject(text) {
+    if (text.trim() === "")
+        return {};
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed === "object" && parsed !== null
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}

package/dist/providers/anthropic-wire.js

@@ -0,0 +1,79 @@
+// Translation between the normalized vocabulary and the Anthropic wire shape.
+// Pure functions, no I/O — which is what makes them testable without a key.
+export function toWireTool(tool) {
+    return { name: tool.name, description: tool.description, input_schema: tool.input };
+}
+export function toWireMessage(message) {
+    if (message.rawFrom === "anthropic" && message.raw !== undefined) {
+        return { role: message.role, content: message.raw };
+    }
+    return { role: message.role, content: message.content.map(toWireBlock) };
+}
+function toWireBlock(block) {
+    if (block.kind === "text")
+        return { type: "text", text: block.text };
+    if (block.kind === "tool_call") {
+        return { type: "tool_use", id: block.id, name: block.name, input: block.input };
+    }
+    return {
+        type: "tool_result",
+        tool_use_id: block.id,
+        content: block.output,
+        is_error: block.isError,
+    };
+}
+/**
+ * Why the model stopped, when that is something the user needs told. Returns
+ * undefined for an ordinary ending.
+ *
+ * `stop_details` is populated for refusals and null for every other stop
+ * reason, so it has to be read behind the check, not before it.
+ */
+export function stopNotice(data) {
+    if (data.stop_reason === "refusal") {
+        const category = data.stop_details?.category ?? "unspecified";
+        const why = data.stop_details?.explanation ?? "no explanation given";
+        return `[refused: ${category}] ${why}`;
+    }
+    if (data.stop_reason === "max_tokens") {
+        return "[truncated: hit max_tokens — raise --max-tokens]";
+    }
+    return undefined;
+}
+export function fromWireResponse(data) {
+    const raw = Array.isArray(data.content) ? data.content : [];
+    const content = [];
+    for (const item of raw) {
+        const block = item;
+        if (block.type === "text" && typeof block.text === "string") {
+            content.push({ kind: "text", text: block.text });
+        }
+        else if (block.type === "tool_use" &&
+            typeof block.id === "string" &&
+            typeof block.name === "string") {
+            content.push({
+                kind: "tool_call",
+                id: block.id,
+                name: block.name,
+                input: (block.input ?? {}),
+            });
+        }
+        // thinking / redacted_thinking and anything future: carried in `raw` only.
+    }
+    const notice = stopNotice(data);
+    if (notice !== undefined)
+        content.push({ kind: "text", text: notice });
+    return { role: "assistant", content, raw, rawFrom: "anthropic", usage: normalizeUsage(data) };
+}
+function normalizeUsage(data) {
+    const usage = data.usage;
+    if (usage === undefined)
+        return undefined;
+    return {
+        inputTokens: usage.input_tokens ?? 0,
+        outputTokens: usage.output_tokens ?? 0,
+        cachedInputTokens: usage.cache_read_input_tokens ?? 0,
+        cacheWriteInputTokens: usage.cache_creation_input_tokens ?? 0,
+        reasoningTokens: 0,
+    };
+}