@gridlock-compute/native-worker 0.1.1

package/dist/inference.js

@@ -0,0 +1,223 @@
+import { BENCHMARK_TOKENS, INFERENCE_BACKEND, MAX_OUTPUT_TOKENS, OLLAMA_MODEL, OLLAMA_URL, OLLAMA_URL_CANDIDATES, VLLM_BASE_URL, VLLM_MODEL, setOllamaUrl, } from "./config.js";
+import { bootstrapOllama, checkOllamaAt, findOllamaBinary, resolveOllamaModel, } from "./ollama.js";
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+let activeBackend = null;
+let activeModel = "";
+export function getActiveBackend() {
+    if (!activeBackend)
+        throw new Error("Inference backend not initialized");
+    return activeBackend;
+}
+export function getActiveModel() {
+    return activeModel;
+}
+export async function checkOllama() {
+    if (process.env.GRIDLOCK_OLLAMA_URL) {
+        return checkOllamaAt(OLLAMA_URL);
+    }
+    for (const url of OLLAMA_URL_CANDIDATES) {
+        if (await checkOllamaAt(url)) {
+            setOllamaUrl(url);
+            return true;
+        }
+    }
+    return false;
+}
+async function ensureOllamaReady(modelPreference) {
+    if (!(await checkOllama())) {
+        const preferredUrl = process.env.GRIDLOCK_OLLAMA_URL?.replace(/\/$/, "") ?? OLLAMA_URL_CANDIDATES[0] ?? OLLAMA_URL;
+        setOllamaUrl(preferredUrl);
+        return bootstrapOllama(OLLAMA_URL, { preferred: modelPreference });
+    }
+    const binary = findOllamaBinary();
+    if (!binary) {
+        return bootstrapOllama(OLLAMA_URL, { preferred: modelPreference });
+    }
+    return resolveOllamaModel(OLLAMA_URL, binary, { preferred: modelPreference });
+}
+export async function checkVllm() {
+    try {
+        const res = await fetch(`${VLLM_BASE_URL}/models`, { signal: AbortSignal.timeout(5000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveInferenceBackend(preferred = INFERENCE_BACKEND, modelPreference) {
+    if (preferred === "ollama") {
+        activeModel = await ensureOllamaReady(modelPreference);
+        activeBackend = "ollama";
+        return activeBackend;
+    }
+    if (preferred === "vllm") {
+        if (!(await checkVllm())) {
+            throw new Error(`vLLM not reachable at ${VLLM_BASE_URL}. Start it with: vllm serve meta-llama/Llama-3.1-8B-Instruct --port 8000`);
+        }
+        activeBackend = "vllm";
+        activeModel = VLLM_MODEL;
+        return activeBackend;
+    }
+    // auto — prefer Ollama (installs on Linux/macOS if missing), fall back to vLLM
+    if (await checkOllama()) {
+        activeModel = await ensureOllamaReady(modelPreference);
+        activeBackend = "ollama";
+        return activeBackend;
+    }
+    try {
+        activeModel = await ensureOllamaReady(modelPreference);
+        activeBackend = "ollama";
+        return activeBackend;
+    }
+    catch (ollamaError) {
+        if (preferred !== "auto")
+            throw ollamaError;
+    }
+    if (await checkVllm()) {
+        activeBackend = "vllm";
+        activeModel = VLLM_MODEL;
+        return activeBackend;
+    }
+    throw new Error("No inference server found.\n" +
+        `  • Ollama: installs automatically on Linux/macOS, or https://ollama.com/download on Windows\n` +
+        `  • vLLM (Linux): vllm serve meta-llama/Llama-3.1-8B-Instruct --port 8000\n` +
+        "Set GRIDLOCK_INFERENCE=ollama|vllm to force one backend.");
+}
+async function runOllamaInference(messages, maxTokens, onProgress) {
+    const model = activeModel || OLLAMA_MODEL;
+    const workerPath = join(dirname(fileURLToPath(import.meta.url)), "inference-ollama-worker.js");
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(workerPath);
+        let settled = false;
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            void worker.terminate();
+            fn();
+        };
+        worker.on("message", (msg) => {
+            if (msg.type === "progress") {
+                onProgress?.({
+                    tokens: Number(msg.tokens ?? 0),
+                    maxTokens: Number(msg.maxTokens ?? maxTokens),
+                });
+                return;
+            }
+            if (msg.type === "done" && msg.result) {
+                finish(() => resolve(msg.result));
+                return;
+            }
+            if (msg.type === "error") {
+                finish(() => reject(new Error(msg.error ?? "Ollama worker failed")));
+            }
+        });
+        worker.on("error", (err) => {
+            finish(() => reject(err));
+        });
+        worker.on("exit", (code) => {
+            if (!settled && code !== 0) {
+                finish(() => reject(new Error(`Ollama worker exited (${code ?? "unknown"})`)));
+            }
+        });
+        worker.postMessage({
+            url: OLLAMA_URL,
+            model,
+            messages,
+            maxTokens,
+        });
+    });
+}
+async function runVllmInference(messages, maxTokens, onProgress) {
+    const start = performance.now();
+    let firstTokenAt = null;
+    let content = "";
+    let tokens = 0;
+    const res = await fetch(`${VLLM_BASE_URL}/chat/completions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            model: VLLM_MODEL,
+            messages,
+            max_tokens: maxTokens,
+            temperature: 0.7,
+            stream: true,
+        }),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`vLLM error ${res.status}: ${text.slice(0, 200)}`);
+    }
+    if (!res.body)
+        throw new Error("vLLM returned empty body");
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("data:"))
+                continue;
+            const payload = trimmed.slice(5).trim();
+            if (payload === "[DONE]")
+                continue;
+            try {
+                const chunk = JSON.parse(payload);
+                const piece = chunk.choices?.[0]?.delta?.content ?? "";
+                if (piece) {
+                    if (firstTokenAt === null)
+                        firstTokenAt = performance.now();
+                    content += piece;
+                    tokens = Math.max(tokens, Math.ceil(content.length / 4));
+                    onProgress?.({ tokens, maxTokens });
+                }
+                const usageTokens = Number(chunk.usage?.completion_tokens ?? 0);
+                if (usageTokens > 0) {
+                    tokens = usageTokens;
+                    onProgress?.({ tokens, maxTokens });
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    const end = performance.now();
+    const ttftMs = Math.floor((firstTokenAt ?? end) - start);
+    const outputTokens = Math.max(tokens, 1);
+    const tpotMs = outputTokens > 1 && firstTokenAt
+        ? Math.floor((end - firstTokenAt) / (outputTokens - 1))
+        : 0;
+    return { content: content.trim() || "(empty)", tokens: outputTokens, ttftMs, tpotMs };
+}
+export async function runInference(messages, maxTokensOrOptions = MAX_OUTPUT_TOKENS, maybeOptions) {
+    let maxTokens = MAX_OUTPUT_TOKENS;
+    let options;
+    if (typeof maxTokensOrOptions === "number") {
+        maxTokens = maxTokensOrOptions;
+        options = maybeOptions;
+    }
+    else {
+        options = maxTokensOrOptions;
+        maxTokens = options.maxTokens ?? MAX_OUTPUT_TOKENS;
+    }
+    const backend = getActiveBackend();
+    const onProgress = options?.onProgress;
+    return backend === "ollama"
+        ? runOllamaInference(messages, maxTokens, onProgress)
+        : runVllmInference(messages, maxTokens, onProgress);
+}
+export async function runBenchmark() {
+    const start = performance.now();
+    const result = await runInference([{ role: "user", content: "Say hi in one word." }], BENCHMARK_TOKENS);
+    const elapsedSec = Math.max((performance.now() - start) / 1000, 0.001);
+    return Math.round((result.tokens / elapsedSec) * 10) / 10;
+}

package/dist/live-stats.d.ts

@@ -0,0 +1,14 @@
+import type { WorkerDashboard } from "./dashboard.js";
+export declare const LIVE_STATS_POLL_MS = 3000;
+export interface LiveStats {
+    jobsToday: number;
+    tokensToday: number;
+    jobsFailedToday: number;
+    workerStatus: string;
+    wsTokPerSec: number;
+    queueJobs: number;
+    inflightJobs: number;
+    workerInflightJobs: number;
+}
+export declare function fetchLiveStats(wallet: string, backendUrl: string): Promise<LiveStats | null>;
+export declare function startLiveStatsPoll(wallet: string, backendUrl: string, dashboard: WorkerDashboard, isRunning: () => boolean): () => void;

package/dist/live-stats.js

@@ -0,0 +1,66 @@
+export const LIVE_STATS_POLL_MS = 3_000;
+async function fetchWorkerLiveStats(wallet, backendUrl) {
+    try {
+        const res = await fetch(`${backendUrl.replace(/\/$/, "")}/v1/workers/${wallet}`);
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        const recentJobs = Array.isArray(data.recent_jobs) ? data.recent_jobs : [];
+        const dayStart = Date.now() / 1000 - 86_400;
+        const recentToday = recentJobs.filter((job) => Number(job.ts ?? 0) >= dayStart);
+        const fallbackTokensToday = recentToday.reduce((sum, job) => sum + Number(job.completion_tokens ?? job.tokens_generated ?? job.output_tokens ?? 0), 0);
+        const fallbackFailedToday = recentToday.filter((job) => job.status === "failed" || job.sla_met === false).length;
+        return {
+            jobsToday: Number(data.jobs_today ?? recentToday.length),
+            tokensToday: Number(data.tokens_today ?? fallbackTokensToday),
+            jobsFailedToday: Number(data.jobs_failed_today ?? fallbackFailedToday),
+            workerStatus: data.status ?? "Active",
+            wsTokPerSec: Number(data.ws_tok_per_sec ?? 0),
+            workerInflightJobs: Number(data.in_flight ?? 0),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchRouterQueueStats(backendUrl) {
+    try {
+        const res = await fetch(`${backendUrl.replace(/\/$/, "")}/v1/stats/ws`);
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return {
+            queueJobs: Number(data.jobs_in_queue ?? 0),
+            inflightJobs: Number(data.jobs_inflight ?? 0),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function fetchLiveStats(wallet, backendUrl) {
+    const [worker, queue] = await Promise.all([
+        fetchWorkerLiveStats(wallet, backendUrl),
+        fetchRouterQueueStats(backendUrl),
+    ]);
+    if (!worker)
+        return null;
+    return {
+        ...worker,
+        queueJobs: queue?.queueJobs ?? 0,
+        inflightJobs: queue?.inflightJobs ?? worker.workerInflightJobs,
+    };
+}
+export function startLiveStatsPoll(wallet, backendUrl, dashboard, isRunning) {
+    const poll = async () => {
+        if (!isRunning())
+            return;
+        const stats = await fetchLiveStats(wallet, backendUrl);
+        if (!stats || !isRunning())
+            return;
+        dashboard.applyLiveStats(stats);
+    };
+    void poll();
+    const timer = setInterval(() => void poll(), LIVE_STATS_POLL_MS);
+    return () => clearInterval(timer);
+}

package/dist/lock.d.ts

@@ -0,0 +1,2 @@
+/** One worker process per wallet — prevents reconnect fights on the router. */
+export declare function acquireWorkerLock(wallet: string): () => void;

package/dist/lock.js

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function lockPath(wallet) {
+    const dir = join(homedir(), ".gridlock");
+    mkdirSync(dir, { recursive: true });
+    return join(dir, `worker-${wallet.toLowerCase()}.lock`);
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** One worker process per wallet — prevents reconnect fights on the router. */
+export function acquireWorkerLock(wallet) {
+    const path = lockPath(wallet);
+    if (existsSync(path)) {
+        const raw = readFileSync(path, "utf8").trim();
+        const pid = Number.parseInt(raw, 10);
+        if (Number.isFinite(pid) && pid !== process.pid && pidAlive(pid)) {
+            throw new Error(`Another worker is already running for this wallet (PID ${pid}).\n` +
+                `  Stop it first: kill ${pid}`);
+        }
+        try {
+            unlinkSync(path);
+        }
+        catch {
+            /* stale */
+        }
+    }
+    writeFileSync(path, String(process.pid), "utf8");
+    return () => {
+        try {
+            if (existsSync(path) && readFileSync(path, "utf8").trim() === String(process.pid)) {
+                unlinkSync(path);
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    };
+}

package/dist/model-select.d.ts

@@ -0,0 +1,3 @@
+import type { OllamaModelInfo } from "./ollama.js";
+export declare function isInteractiveTerminal(): boolean;
+export declare function promptOllamaModel(models: OllamaModelInfo[], preferred: string): Promise<string>;

package/dist/model-select.js

@@ -0,0 +1,39 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+function formatSizeGb(bytes) {
+    if (!bytes || bytes <= 0)
+        return "—";
+    return `${(bytes / 1e9).toFixed(1)} GB`;
+}
+export function isInteractiveTerminal() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+export async function promptOllamaModel(models, preferred) {
+    if (models.length === 0)
+        return preferred;
+    console.log("\nInstalled Ollama models:\n");
+    for (let i = 0; i < models.length; i += 1) {
+        const m = models[i];
+        console.log(`  ${i + 1}. ${m.name} (${formatSizeGb(m.size)})`);
+    }
+    const pullOption = models.length + 1;
+    console.log(`  ${pullOption}. Pull ${preferred} (default — not installed yet)\n`);
+    const rl = createInterface({ input, output });
+    try {
+        while (true) {
+            const answer = (await rl.question(`Select model [1-${pullOption}, default 1]: `)).trim();
+            if (!answer)
+                return models[0].name;
+            const choice = Number.parseInt(answer, 10);
+            if (Number.isFinite(choice) && choice >= 1 && choice <= models.length) {
+                return models[choice - 1].name;
+            }
+            if (choice === pullOption)
+                return preferred;
+            console.log(`Enter a number between 1 and ${pullOption}.`);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/ollama.d.ts

@@ -0,0 +1,22 @@
+export declare function checkOllamaAt(baseUrl: string): Promise<boolean>;
+export declare function findOllamaBinary(): string | null;
+/** Install Ollama on Linux/macOS when missing (official install script). */
+export declare function installOllama(): Promise<void>;
+export declare function resolveOllamaBinary(): Promise<string>;
+export declare function startOllamaServe(binary: string): void;
+export declare function waitForOllama(baseUrl: string, timeoutMs?: number): Promise<boolean>;
+export interface OllamaModelInfo {
+    name: string;
+    size: number;
+}
+export declare function listOllamaModels(baseUrl: string): Promise<OllamaModelInfo[]>;
+export declare function findModelMatch(models: OllamaModelInfo[], preferred: string): string | null;
+export declare function pickInstalledFallback(models: OllamaModelInfo[], preferred: string): string | null;
+export declare function ensureOllamaModel(baseUrl: string, binary: string, model: string): Promise<void>;
+export interface ResolveOllamaModelOptions {
+    /** User-requested model (--model); pulls if missing instead of picking another install. */
+    preferred?: string;
+    interactive?: boolean;
+}
+export declare function resolveOllamaModel(baseUrl: string, binary: string, options?: ResolveOllamaModelOptions): Promise<string>;
+export declare function bootstrapOllama(baseUrl: string, modelOptions?: ResolveOllamaModelOptions): Promise<string>;

package/dist/ollama.js

@@ -0,0 +1,195 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { workerLog } from "./console-io.js";
+import { isInteractiveTerminal, promptOllamaModel } from "./model-select.js";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function checkOllamaAt(baseUrl) {
+    try {
+        const res = await fetch(`${baseUrl}/api/version`, { signal: AbortSignal.timeout(5000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export function findOllamaBinary() {
+    const candidates = [];
+    if (process.env.GRIDLOCK_OLLAMA_BIN) {
+        candidates.push(process.env.GRIDLOCK_OLLAMA_BIN);
+    }
+    if (process.platform === "win32") {
+        if (process.env.LOCALAPPDATA) {
+            candidates.push(join(process.env.LOCALAPPDATA, "Programs", "Ollama", "ollama.exe"));
+        }
+        if (process.env.ProgramFiles) {
+            candidates.push(join(process.env.ProgramFiles, "Ollama", "ollama.exe"));
+        }
+    }
+    candidates.push("ollama");
+    for (const candidate of candidates) {
+        if (candidate.includes("/") || candidate.includes("\\")) {
+            if (existsSync(candidate))
+                return candidate;
+            continue;
+        }
+        try {
+            const cmd = process.platform === "win32" ? "where" : "which";
+            const out = spawnSync(cmd, [candidate], { encoding: "utf8" });
+            if (out.status === 0 && out.stdout.trim()) {
+                return out.stdout.trim().split(/\r?\n/)[0] ?? candidate;
+            }
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return null;
+}
+/** Install Ollama on Linux/macOS when missing (official install script). */
+export async function installOllama() {
+    if (process.platform === "win32") {
+        throw new Error("Ollama is not installed.\n" +
+            "  1. Download from https://ollama.com/download\n" +
+            "  2. Install, then open Ollama from the Start menu\n" +
+            "  3. Re-run this worker");
+    }
+    if (process.env.GRIDLOCK_SKIP_OLLAMA_INSTALL === "true") {
+        throw new Error("Ollama is not installed. Set GRIDLOCK_SKIP_OLLAMA_INSTALL=false or install from https://ollama.com/download");
+    }
+    workerLog("Ollama not found — installing via https://ollama.com/install.sh …");
+    const result = spawnSync("sh", ["-c", "curl -fsSL https://ollama.com/install.sh | sh"], {
+        stdio: "inherit",
+    });
+    if (result.status !== 0) {
+        throw new Error("Ollama install failed. Install manually: curl -fsSL https://ollama.com/install.sh | sh");
+    }
+}
+export async function resolveOllamaBinary() {
+    const existing = findOllamaBinary();
+    if (existing)
+        return existing;
+    await installOllama();
+    const binary = findOllamaBinary();
+    if (!binary) {
+        throw new Error("Ollama install completed but binary not found in PATH. Restart your shell and retry.");
+    }
+    return binary;
+}
+export function startOllamaServe(binary) {
+    const child = spawn(binary, ["serve"], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.unref();
+}
+export async function waitForOllama(baseUrl, timeoutMs = 45000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await checkOllamaAt(baseUrl))
+            return true;
+        await sleep(750);
+    }
+    return false;
+}
+export async function listOllamaModels(baseUrl) {
+    try {
+        const res = await fetch(`${baseUrl}/api/tags`, { signal: AbortSignal.timeout(8000) });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        return (data.models ?? [])
+            .map((m) => ({ name: String(m.name ?? "").trim(), size: Number(m.size ?? 0) }))
+            .filter((m) => m.name.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+export function findModelMatch(models, preferred) {
+    const want = preferred.trim();
+    if (!want)
+        return null;
+    const names = models.map((m) => m.name);
+    if (names.includes(want))
+        return want;
+    const base = want.split(":", 1)[0] ?? want;
+    return names.find((n) => n === base || n.startsWith(`${base}:`)) ?? null;
+}
+const FALLBACK_MODEL_CANDIDATES = ["llama3.2:3b", "llama3.1:8b", "phi3:mini"];
+export function pickInstalledFallback(models, preferred) {
+    for (const candidate of [preferred, ...FALLBACK_MODEL_CANDIDATES]) {
+        const hit = findModelMatch(models, candidate);
+        if (hit)
+            return hit;
+    }
+    return models[0]?.name ?? null;
+}
+async function modelIsAvailable(baseUrl, model) {
+    const installed = await listOllamaModels(baseUrl);
+    return findModelMatch(installed, model) !== null;
+}
+export async function ensureOllamaModel(baseUrl, binary, model) {
+    if (await modelIsAvailable(baseUrl, model))
+        return;
+    workerLog(`Pulling Ollama model ${model}… (one-time download, may take several minutes)`);
+    const result = spawnSync(binary, ["pull", model], { stdio: "inherit" });
+    if (result.status !== 0) {
+        throw new Error(`Failed to pull ${model}. Run manually: ollama pull ${model}`);
+    }
+}
+export async function resolveOllamaModel(baseUrl, binary, options = {}) {
+    const explicitPreferred = Boolean(options.preferred?.trim());
+    const preferred = (options.preferred ?? process.env.GRIDLOCK_OLLAMA_MODEL ?? "llama3.1:8b").trim();
+    const interactive = options.interactive ?? isInteractiveTerminal();
+    const installed = await listOllamaModels(baseUrl);
+    const preferredHit = findModelMatch(installed, preferred);
+    if (preferredHit)
+        return preferredHit;
+    if (explicitPreferred) {
+        workerLog(`Pulling requested Ollama model ${preferred}…`);
+        await ensureOllamaModel(baseUrl, binary, preferred);
+        return preferred;
+    }
+    if (installed.length === 1) {
+        const only = installed[0].name;
+        workerLog(`Using installed Ollama model: ${only}`);
+        return only;
+    }
+    if (installed.length > 1) {
+        if (interactive) {
+            const picked = await promptOllamaModel(installed, preferred);
+            if (findModelMatch(installed, picked))
+                return picked;
+            await ensureOllamaModel(baseUrl, binary, picked);
+            return picked;
+        }
+        const fallback = pickInstalledFallback(installed, preferred);
+        if (fallback) {
+            workerLog(`Using installed Ollama model: ${fallback}`);
+            return fallback;
+        }
+    }
+    workerLog(installed.length === 0
+        ? `No Ollama models installed. Pulling ${preferred}…`
+        : `Preferred model ${preferred} not installed. Pulling…`);
+    await ensureOllamaModel(baseUrl, binary, preferred);
+    return preferred;
+}
+export async function bootstrapOllama(baseUrl, modelOptions = {}) {
+    const binary = await resolveOllamaBinary();
+    if (!(await checkOllamaAt(baseUrl))) {
+        workerLog("Ollama not running — starting it…");
+        startOllamaServe(binary);
+        if (!(await waitForOllama(baseUrl))) {
+            throw new Error(`Ollama did not respond at ${baseUrl}.\n` +
+                (process.platform === "win32"
+                    ? "  Open the Ollama app from the Start menu (system tray), wait a few seconds, then retry."
+                    : "  Check: systemctl status ollama  — or run: ollama serve"));
+        }
+    }
+    return resolveOllamaModel(baseUrl, binary, modelOptions);
+}

package/dist/wallet.d.ts

@@ -0,0 +1,2 @@
+export declare function parseWorkerWallet(raw: string): `0x${string}`;
+export declare function shortWallet(addr: string): string;

package/dist/wallet.js

@@ -0,0 +1,14 @@
+import { getAddress, isAddress } from "viem";
+export function parseWorkerWallet(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new Error("Wallet address is required.");
+    }
+    if (!isAddress(trimmed)) {
+        throw new Error("Invalid EVM wallet address. Use your EVM wallet 0x address (same as on https://grid-lock.tech/worker).");
+    }
+    return getAddress(trimmed);
+}
+export function shortWallet(addr) {
+    return addr.length >= 10 ? `${addr.slice(0, 6)}…${addr.slice(-4)}` : addr;
+}

package/dist/worker.d.ts

@@ -0,0 +1,10 @@
+import type { InferenceBackend } from "./config.js";
+interface WorkerOptions {
+    wallet: string;
+    backendUrl: string;
+    benchmarkOnly?: boolean;
+    inference?: InferenceBackend;
+    model?: string;
+}
+export declare function startWorker(options: WorkerOptions): Promise<void>;
+export {};