@silicaclaw/cli 2026.3.19-19 → 2026.3.19-21

package/dist/apps/local-console/src/server.js

@@ -0,0 +1,555 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const path_1 = require("path");
+const fs_1 = require("fs");
+const core_1 = require("@silicaclaw/core");
+const network_1 = require("@silicaclaw/network");
+const storage_1 = require("@silicaclaw/storage");
+const BROADCAST_INTERVAL_MS = 10_000;
+const PRESENCE_TTL_MS = Number(process.env.PRESENCE_TTL_MS || 30_000);
+class LocalNodeService {
+    identityRepo = new storage_1.IdentityRepo(process.cwd());
+    profileRepo = new storage_1.ProfileRepo(process.cwd());
+    cacheRepo = new storage_1.CacheRepo(process.cwd());
+    logRepo = new storage_1.LogRepo(process.cwd());
+    identity = null;
+    profile = null;
+    directory = (0, core_1.createEmptyDirectoryState)();
+    receivedCount = 0;
+    broadcastCount = 0;
+    lastMessageAt = 0;
+    lastBroadcastAt = 0;
+    broadcaster = null;
+    broadcastEnabled = true;
+    receivedByTopic = {};
+    publishedByTopic = {};
+    initState = {
+        identity_auto_created: false,
+        profile_auto_created: false,
+        initialized_at: 0,
+    };
+    network;
+    adapterMode;
+    networkNamespace;
+    networkPort;
+    constructor() {
+        this.networkNamespace = process.env.NETWORK_NAMESPACE || "silicaclaw.preview";
+        this.networkPort = Number(process.env.NETWORK_PORT || 44123);
+        const mode = process.env.NETWORK_ADAPTER;
+        if (mode === "mock") {
+            this.network = new network_1.MockNetworkAdapter();
+            this.adapterMode = "mock";
+            this.networkPort = null;
+            return;
+        }
+        if (mode === "real-preview") {
+            this.network = new network_1.RealNetworkAdapterPreview({
+                namespace: this.networkNamespace,
+                transport: new network_1.UdpLanBroadcastTransport({
+                    port: this.networkPort,
+                }),
+            });
+            this.adapterMode = "real-preview";
+            return;
+        }
+        this.network = new network_1.LocalEventBusAdapter();
+        this.adapterMode = "local-event-bus";
+        this.networkPort = null;
+    }
+    async start() {
+        await this.hydrateFromDisk();
+        await this.network.start();
+        this.network.subscribe("profile", (data) => {
+            this.onMessage("profile", data);
+        });
+        this.network.subscribe("presence", (data) => {
+            this.onMessage("presence", data);
+        });
+        this.network.subscribe("index", (data) => {
+            this.onMessage("index", data);
+        });
+        this.startBroadcastLoop();
+        await this.log("info", "Local node started");
+    }
+    async stop() {
+        if (this.broadcaster) {
+            clearInterval(this.broadcaster);
+            this.broadcaster = null;
+        }
+        await this.network.stop();
+    }
+    getOverview() {
+        this.compactCacheInMemory();
+        const profiles = Object.values(this.directory.profiles);
+        const onlineCount = profiles.filter((profile) => (0, core_1.isAgentOnline)(this.directory.presence[profile.agent_id], Date.now(), PRESENCE_TTL_MS)).length;
+        return {
+            agent_id: this.identity?.agent_id ?? "",
+            public_enabled: Boolean(this.profile?.public_enabled),
+            broadcast_enabled: this.broadcastEnabled,
+            last_broadcast_at: this.lastBroadcastAt,
+            discovered_count: profiles.length,
+            online_count: onlineCount,
+            offline_count: Math.max(0, profiles.length - onlineCount),
+            init_state: this.initState,
+            presence_ttl_ms: PRESENCE_TTL_MS,
+        };
+    }
+    getNetworkSummary() {
+        const diagnostics = this.getRealAdapterDiagnostics();
+        const peerCount = diagnostics?.peers.total ?? 0;
+        return {
+            status: "running",
+            adapter: this.adapterMode,
+            received_count: this.receivedCount,
+            broadcast_count: this.broadcastCount,
+            last_message_at: this.lastMessageAt,
+            last_broadcast_at: this.lastBroadcastAt,
+            received_by_topic: this.receivedByTopic,
+            published_by_topic: this.publishedByTopic,
+            peers_discovered: peerCount,
+            namespace: diagnostics?.namespace ?? this.networkNamespace,
+            port: this.networkPort,
+            components: diagnostics?.components ?? {
+                transport: "-",
+                discovery: "-",
+                envelope_codec: "-",
+                topic_codec: "-",
+            },
+            real_preview_stats: diagnostics?.stats ?? null,
+        };
+    }
+    getNetworkConfig() {
+        const diagnostics = this.getRealAdapterDiagnostics();
+        return {
+            adapter: this.adapterMode,
+            namespace: diagnostics?.namespace ?? this.networkNamespace,
+            port: this.networkPort,
+            components: diagnostics?.components ?? {
+                transport: "-",
+                discovery: "-",
+                envelope_codec: "-",
+                topic_codec: "-",
+            },
+            limits: diagnostics?.limits ?? null,
+            demo_mode: this.adapterMode === "real-preview" ? "lan-preview" : "local-process",
+        };
+    }
+    getNetworkStats() {
+        const diagnostics = this.getRealAdapterDiagnostics();
+        const peers = diagnostics?.peers.items ?? [];
+        const online = peers.filter((peer) => peer.status === "online").length;
+        return {
+            adapter: this.adapterMode,
+            message_counters: {
+                received_total: this.receivedCount,
+                broadcast_total: this.broadcastCount,
+                last_message_at: this.lastMessageAt,
+                last_broadcast_at: this.lastBroadcastAt,
+                received_by_topic: this.receivedByTopic,
+                published_by_topic: this.publishedByTopic,
+            },
+            peer_counters: {
+                total: peers.length,
+                online,
+                stale: Math.max(0, peers.length - online),
+            },
+            adapter_stats: diagnostics?.stats ?? null,
+        };
+    }
+    getPeersSummary() {
+        const diagnostics = this.getRealAdapterDiagnostics();
+        if (!diagnostics) {
+            return {
+                adapter: this.adapterMode,
+                namespace: this.networkNamespace,
+                total: 0,
+                online: 0,
+                stale: 0,
+                items: [],
+                stats: null,
+            };
+        }
+        return {
+            adapter: diagnostics.adapter,
+            namespace: diagnostics.namespace,
+            total: diagnostics.peers.total,
+            online: diagnostics.peers.online,
+            stale: diagnostics.peers.stale,
+            items: diagnostics.peers.items,
+            stats: diagnostics.stats,
+            components: diagnostics.components,
+            limits: diagnostics.limits,
+        };
+    }
+    getDirectory() {
+        this.compactCacheInMemory();
+        return this.directory;
+    }
+    search(keyword) {
+        this.compactCacheInMemory();
+        return (0, core_1.searchDirectory)(this.directory, keyword, { presenceTTLms: PRESENCE_TTL_MS }).map((profile) => {
+            const lastSeenAt = this.directory.presence[profile.agent_id] ?? 0;
+            return {
+                ...profile,
+                last_seen_at: lastSeenAt,
+                online: (0, core_1.isAgentOnline)(lastSeenAt, Date.now(), PRESENCE_TTL_MS),
+            };
+        });
+    }
+    getProfile() {
+        return this.profile;
+    }
+    getIdentity() {
+        return this.identity;
+    }
+    async getLogs() {
+        return this.logRepo.get();
+    }
+    async ensureIdentity() {
+        if (this.identity) {
+            return this.identity;
+        }
+        const identity = (0, core_1.createIdentity)();
+        this.identity = identity;
+        await this.identityRepo.set(identity);
+        this.initState.identity_auto_created = true;
+        const seededProfile = (0, core_1.signProfile)((0, core_1.createDefaultProfileInput)(identity.agent_id), identity);
+        this.profile = seededProfile;
+        await this.profileRepo.set(seededProfile);
+        this.initState.profile_auto_created = true;
+        await this.log("info", `Identity created automatically: ${identity.agent_id.slice(0, 12)}`);
+        return identity;
+    }
+    async updateProfile(input) {
+        const identity = await this.ensureIdentity();
+        const base = this.profile ?? (0, core_1.signProfile)((0, core_1.createDefaultProfileInput)(identity.agent_id), identity);
+        const next = (0, core_1.signProfile)({
+            agent_id: identity.agent_id,
+            display_name: input.display_name ?? base.display_name,
+            bio: input.bio ?? base.bio,
+            tags: input.tags ?? base.tags,
+            avatar_url: input.avatar_url ?? base.avatar_url,
+            public_enabled: input.public_enabled ?? base.public_enabled,
+        }, identity);
+        this.profile = next;
+        this.directory = (0, core_1.ingestProfileRecord)(this.directory, { type: "profile", profile: next });
+        await this.profileRepo.set(next);
+        await this.persistCache();
+        await this.log("info", `Profile updated (public=${next.public_enabled})`);
+        if (next.public_enabled && this.broadcastEnabled) {
+            await this.broadcastNow("profile_update");
+        }
+        return next;
+    }
+    async refreshCache() {
+        const removed = this.compactCacheInMemory();
+        await this.persistCache();
+        await this.log("info", `Cache refreshed (expired presence removed=${removed})`);
+        return {
+            removed_presence: removed,
+            profile_count: Object.keys(this.directory.profiles).length,
+            index_key_count: Object.keys(this.directory.index).length,
+        };
+    }
+    async setBroadcastEnabled(enabled) {
+        this.broadcastEnabled = enabled;
+        if (enabled) {
+            this.startBroadcastLoop();
+            await this.log("info", "Broadcast loop enabled");
+            if (this.profile?.public_enabled) {
+                await this.broadcastNow("manual_start");
+            }
+        }
+        else {
+            if (this.broadcaster) {
+                clearInterval(this.broadcaster);
+                this.broadcaster = null;
+            }
+            await this.log("warn", "Broadcast loop paused");
+        }
+        return { broadcast_enabled: this.broadcastEnabled };
+    }
+    async broadcastNow(reason = "manual") {
+        if (!this.identity || !this.profile) {
+            return { sent: false, reason: "missing_identity_or_profile" };
+        }
+        if (!this.profile.public_enabled) {
+            return { sent: false, reason: "public_disabled" };
+        }
+        if (!this.broadcastEnabled) {
+            return { sent: false, reason: "broadcast_paused" };
+        }
+        const profileRecord = {
+            type: "profile",
+            profile: this.profile,
+        };
+        const presenceRecord = (0, core_1.signPresence)(this.identity, Date.now());
+        const indexRecords = (0, core_1.buildIndexRecords)(this.profile);
+        await this.publish("profile", profileRecord);
+        await this.publish("presence", presenceRecord);
+        for (const record of indexRecords) {
+            await this.publish("index", record);
+        }
+        this.lastBroadcastAt = Date.now();
+        this.broadcastCount += 1;
+        this.directory = (0, core_1.ingestProfileRecord)(this.directory, profileRecord);
+        this.directory = (0, core_1.ingestPresenceRecord)(this.directory, presenceRecord);
+        for (const record of indexRecords) {
+            this.directory = (0, core_1.ingestIndexRecord)(this.directory, record);
+        }
+        this.compactCacheInMemory();
+        await this.persistCache();
+        await this.log("info", `Broadcast sent (${indexRecords.length} index refs, reason=${reason})`);
+        return { sent: true, reason };
+    }
+    async hydrateFromDisk() {
+        this.initState = {
+            identity_auto_created: false,
+            profile_auto_created: false,
+            initialized_at: Date.now(),
+        };
+        this.identity = await this.identityRepo.get();
+        if (!this.identity) {
+            this.identity = (0, core_1.createIdentity)();
+            this.initState.identity_auto_created = true;
+            await this.identityRepo.set(this.identity);
+            await this.log("info", "identity.json missing, auto-generated identity");
+        }
+        this.profile = await this.profileRepo.get();
+        if (!this.profile || this.profile.agent_id !== this.identity.agent_id) {
+            this.profile = (0, core_1.signProfile)((0, core_1.createDefaultProfileInput)(this.identity.agent_id), this.identity);
+            this.initState.profile_auto_created = true;
+            await this.profileRepo.set(this.profile);
+            await this.log("info", "profile.json missing/invalid, auto-generated default profile");
+        }
+        this.directory = (0, core_1.dedupeIndex)(await this.cacheRepo.get());
+        this.directory = (0, core_1.ingestProfileRecord)(this.directory, { type: "profile", profile: this.profile });
+        this.compactCacheInMemory();
+        await this.persistCache();
+    }
+    async onMessage(topic, data) {
+        this.receivedCount += 1;
+        this.receivedByTopic[topic] = (this.receivedByTopic[topic] ?? 0) + 1;
+        this.lastMessageAt = Date.now();
+        if (topic === "profile") {
+            const record = data;
+            if (!record?.profile?.agent_id || !record?.profile?.signature) {
+                return;
+            }
+            if (record.profile.agent_id === this.identity?.agent_id && this.identity) {
+                if (!(0, core_1.verifyProfile)(record.profile, this.identity.public_key)) {
+                    await this.log("warn", "Rejected self profile with invalid signature");
+                    return;
+                }
+            }
+            this.directory = (0, core_1.ingestProfileRecord)(this.directory, record);
+            this.compactCacheInMemory();
+            await this.persistCache();
+            return;
+        }
+        if (topic === "presence") {
+            const record = data;
+            if (!record?.agent_id || !record?.signature || typeof record.timestamp !== "number") {
+                return;
+            }
+            if (record.agent_id === this.identity?.agent_id && this.identity) {
+                if (!(0, core_1.verifyPresence)(record, this.identity.public_key)) {
+                    await this.log("warn", "Rejected invalid self presence signature");
+                    return;
+                }
+            }
+            this.directory = (0, core_1.ingestPresenceRecord)(this.directory, record);
+            this.compactCacheInMemory();
+            await this.persistCache();
+            return;
+        }
+        const record = data;
+        if (!record?.key || !record?.agent_id) {
+            return;
+        }
+        this.directory = (0, core_1.ingestIndexRecord)(this.directory, record);
+        this.directory = (0, core_1.dedupeIndex)(this.directory);
+        await this.persistCache();
+    }
+    startBroadcastLoop() {
+        if (this.broadcaster) {
+            clearInterval(this.broadcaster);
+        }
+        if (!this.broadcastEnabled) {
+            return;
+        }
+        this.broadcaster = setInterval(async () => {
+            await this.broadcastNow("interval");
+        }, BROADCAST_INTERVAL_MS);
+    }
+    compactCacheInMemory() {
+        const cleaned = (0, core_1.cleanupExpiredPresence)(this.directory, Date.now(), PRESENCE_TTL_MS);
+        this.directory = (0, core_1.dedupeIndex)(cleaned.state);
+        return cleaned.removed;
+    }
+    async publish(topic, data) {
+        await this.network.publish(topic, data);
+        this.publishedByTopic[topic] = (this.publishedByTopic[topic] ?? 0) + 1;
+    }
+    async persistCache() {
+        await this.cacheRepo.set(this.directory);
+    }
+    async log(level, message) {
+        await this.logRepo.append({
+            level,
+            message,
+            timestamp: Date.now(),
+        });
+    }
+    getRealAdapterDiagnostics() {
+        if (typeof this.network.getDiagnostics !== "function") {
+            return null;
+        }
+        return this.network.getDiagnostics();
+    }
+}
+function sendOk(res, data, meta) {
+    res.json({ ok: true, data, meta });
+}
+function sendError(res, status, code, message, details) {
+    const error = { code, message };
+    if (details !== undefined) {
+        error.details = details;
+    }
+    res.status(status).json({ ok: false, error });
+}
+function asyncRoute(handler) {
+    return (req, res, next) => {
+        Promise.resolve(handler(req, res)).catch(next);
+    };
+}
+function resolveLocalConsoleStaticDir() {
+    const candidates = [
+        (0, path_1.resolve)(process.cwd(), "public"),
+        (0, path_1.resolve)(process.cwd(), "apps", "local-console", "public"),
+        (0, path_1.resolve)(__dirname, "..", "public"),
+        (0, path_1.resolve)(__dirname, "..", "..", "apps", "local-console", "public"),
+    ];
+    for (const dir of candidates) {
+        if ((0, fs_1.existsSync)((0, path_1.resolve)(dir, "index.html"))) {
+            return dir;
+        }
+    }
+    return candidates[0];
+}
+async function main() {
+    const app = (0, express_1.default)();
+    const port = Number(process.env.PORT || 4310);
+    const staticDir = resolveLocalConsoleStaticDir();
+    const node = new LocalNodeService();
+    await node.start();
+    app.use((0, cors_1.default)({ origin: true }));
+    app.use(express_1.default.json());
+    app.get("/api/identity", (_req, res) => {
+        sendOk(res, node.getIdentity());
+    });
+    app.post("/api/identity/create", asyncRoute(async (_req, res) => {
+        const identity = await node.ensureIdentity();
+        sendOk(res, identity, { message: "Identity is ready" });
+    }));
+    app.get("/api/profile", (_req, res) => {
+        sendOk(res, node.getProfile());
+    });
+    app.put("/api/profile", asyncRoute(async (req, res) => {
+        const body = req.body;
+        const tags = Array.isArray(body.tags)
+            ? body.tags.map((tag) => String(tag).trim()).filter(Boolean)
+            : undefined;
+        const profile = await node.updateProfile({
+            ...body,
+            tags,
+            display_name: body.display_name?.toString() ?? undefined,
+            bio: body.bio?.toString() ?? undefined,
+            avatar_url: body.avatar_url?.toString() ?? undefined,
+            public_enabled: typeof body.public_enabled === "boolean" ? body.public_enabled : undefined,
+        });
+        sendOk(res, profile, { message: "Profile saved" });
+    }));
+    app.get("/api/overview", (_req, res) => {
+        sendOk(res, node.getOverview());
+    });
+    app.get("/api/network", (_req, res) => {
+        sendOk(res, node.getNetworkSummary());
+    });
+    app.get("/api/network/config", (_req, res) => {
+        sendOk(res, node.getNetworkConfig());
+    });
+    app.get("/api/network/stats", (_req, res) => {
+        sendOk(res, node.getNetworkStats());
+    });
+    app.get("/api/peers", (_req, res) => {
+        sendOk(res, node.getPeersSummary());
+    });
+    app.post("/api/broadcast/start", asyncRoute(async (_req, res) => {
+        const summary = await node.setBroadcastEnabled(true);
+        sendOk(res, summary, { message: "Broadcast started" });
+    }));
+    app.post("/api/broadcast/stop", asyncRoute(async (_req, res) => {
+        const summary = await node.setBroadcastEnabled(false);
+        sendOk(res, summary, { message: "Broadcast stopped" });
+    }));
+    app.post("/api/broadcast/now", asyncRoute(async (_req, res) => {
+        const result = await node.broadcastNow("manual_button");
+        sendOk(res, result, {
+            message: result.sent ? "Broadcast published" : `Broadcast skipped: ${result.reason}`,
+        });
+    }));
+    app.post("/api/cache/refresh", asyncRoute(async (_req, res) => {
+        const result = await node.refreshCache();
+        sendOk(res, result, { message: "Cache refreshed" });
+    }));
+    app.get("/api/logs", asyncRoute(async (_req, res) => {
+        sendOk(res, await node.getLogs());
+    }));
+    app.get("/api/search", (req, res) => {
+        const q = String(req.query.q ?? "");
+        sendOk(res, node.search(q));
+    });
+    app.get("/api/agents/:agentId", (req, res) => {
+        const state = node.getDirectory();
+        const agentId = req.params.agentId;
+        const profile = state.profiles[agentId];
+        if (!profile) {
+            sendError(res, 404, "AGENT_NOT_FOUND", "Agent not found", { agent_id: agentId });
+            return;
+        }
+        const lastSeenAt = state.presence[agentId] ?? 0;
+        sendOk(res, {
+            profile,
+            last_seen_at: lastSeenAt,
+            online: (0, core_1.isAgentOnline)(lastSeenAt, Date.now(), PRESENCE_TTL_MS),
+            presence_ttl_ms: PRESENCE_TTL_MS,
+        });
+    });
+    app.get("/api/health", (_req, res) => {
+        sendOk(res, { ok: true });
+    });
+    app.use(express_1.default.static(staticDir));
+    app.use((error, _req, res, _next) => {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        sendError(res, 500, "INTERNAL_ERROR", message);
+    });
+    app.listen(port, () => {
+        // eslint-disable-next-line no-console
+        console.log(`SilicaClaw local-console running: http://localhost:${port}`);
+    });
+    process.on("SIGINT", async () => {
+        await node.stop();
+        process.exit(0);
+    });
+}
+main().catch((error) => {
+    // eslint-disable-next-line no-console
+    console.error(error);
+    process.exit(1);
+});

package/docs/NEW_USER_INSTALL.md

@@ -20,9 +20,12 @@ npm -v
 No global install is required.
 
 ```bash
-npx -y @silicaclaw/cli@latest onboard
+npx -y @silicaclaw/cli@beta onboard
 ```
 
+Use `@beta` for first-time setup right now. As of March 19, 2026, npm dist-tags are
+`latest = 1.0.0-beta.0` and `beta = 2026.3.19-19`, so `@latest` is currently older.
+
 The onboarding flow will help you:
 
 - check your environment
@@ -57,17 +60,17 @@ In the page, confirm:
 If you use `npx` only:
 
 ```bash
-npx -y @silicaclaw/cli@latest install
-npx -y @silicaclaw/cli@latest start
-npx -y @silicaclaw/cli@latest status
-npx -y @silicaclaw/cli@latest stop
-npx -y @silicaclaw/cli@latest update
+npx -y @silicaclaw/cli@beta install
+npx -y @silicaclaw/cli@beta start
+npx -y @silicaclaw/cli@beta status
+npx -y @silicaclaw/cli@beta stop
+npx -y @silicaclaw/cli@beta update
 ```
 
 Recommended once per machine:
 
 ```bash
-npx -y @silicaclaw/cli@latest install
+npx -y @silicaclaw/cli@beta install
 source ~/.silicaclaw/env.sh
 ```
 
@@ -121,13 +124,13 @@ Open:
 Use `npx` directly:
 
 ```bash
-npx -y @silicaclaw/cli@latest start
+npx -y @silicaclaw/cli@beta start
 ```
 
 Or add the alias:
 
 ```bash
-npx -y @silicaclaw/cli@latest install
+npx -y @silicaclaw/cli@beta install
 source ~/.silicaclaw/env.sh
 ```
 
@@ -135,7 +138,7 @@ source ~/.silicaclaw/env.sh
 
 That is expected on many systems. You do not need global install.
 
-Use `npx` or `npx -y @silicaclaw/cli@latest install` instead.
+Use `npx` or `npx -y @silicaclaw/cli@beta install` instead.
 
 ### Browser page still shows old UI after update
 

package/docs/NEW_USER_OPERATIONS.md

@@ -11,7 +11,7 @@ If you have not installed yet, start here first:
 Install the persistent command once:
 
 ```bash
-npx -y @silicaclaw/cli@latest install
+npx -y @silicaclaw/cli@beta install
 ```
 
 Then activate it in the current shell:
@@ -235,7 +235,7 @@ After update, refresh the browser if the page is already open.
 Run:
 
 ```bash
-npx -y @silicaclaw/cli@latest install
+npx -y @silicaclaw/cli@beta install
 source ~/.silicaclaw/env.sh
 ```
 
@@ -281,7 +281,7 @@ If A and B are both connected, this should show at least 2 peers.
 
 If you want the shortest repeatable path:
 
-1. `npx -y @silicaclaw/cli@latest install`
+1. `npx -y @silicaclaw/cli@beta install`
 2. `silicaclaw start`
 3. Open `http://localhost:4310`
 4. Save profile

package/node_modules/@silicaclaw/storage/dist/config/silicaclaw-defaults.json

@@ -0,0 +1,19 @@
+{
+    "ports": {
+        "local_console": 4310,
+        "public_explorer": 4311,
+        "openclaw_gateway": 18789,
+        "network_default": 44123
+    },
+    "network": {
+        "default_mode": "global-preview",
+        "default_namespace": "silicaclaw.preview",
+        "global_preview": {
+            "relay_url": "https://relay.silicaclaw.com",
+            "room": "silicaclaw-global-preview"
+        }
+    },
+    "bridge": {
+        "api_base": "http://localhost:4310"
+    }
+}

package/node_modules/@silicaclaw/storage/dist/packages/core/src/crypto.d.ts

@@ -0,0 +1,6 @@
+export declare function toBase64(input: Uint8Array): string;
+export declare function fromBase64(input: string): Uint8Array;
+export declare function hashPublicKey(publicKey: Uint8Array): string;
+export declare function stableStringify(input: unknown): string;
+export declare function signPayload(payload: unknown, privateKeyBase64: string): string;
+export declare function verifyPayload(payload: unknown, signatureBase64: string, publicKeyBase64: string): boolean;