@bcts/hubert 1.0.0-alpha.17

package/dist/server-DVyk9gqU.mjs

@@ -0,0 +1,836 @@
+import { a as AlreadyExistsError, i as verbosePrintln, n as verboseNewline, o as HubertError, r as verbosePrintDot } from "./logging-hmzNzifq.mjs";
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as path$1 from "path";
+import Fastify from "fastify";
+import { ARID } from "@bcts/components";
+import { Envelope } from "@bcts/envelope";
+
+//#region src/server/error.ts
+/**
+* Server-specific error types.
+*
+* Port of server/error.rs from hubert-rust.
+*
+* @module
+*/
+/**
+* Base error class for server errors.
+*
+* @category Server Errors
+*/
+var ServerError = class extends HubertError {
+	constructor(message) {
+		super(message);
+		this.name = "ServerError";
+	}
+};
+/**
+* General server error.
+*
+* Port of `Error::General(String)` from server/error.rs line 4.
+*
+* @category Server Errors
+*/
+var ServerGeneralError = class extends ServerError {
+	constructor(message) {
+		super(`Server error: ${message}`);
+		this.name = "ServerGeneralError";
+	}
+};
+/**
+* Network error during server communication.
+*
+* Port of `Error::NetworkError(String)` from server/error.rs line 7.
+*
+* @category Server Errors
+*/
+var ServerNetworkError = class extends ServerError {
+	constructor(message) {
+		super(`Network error: ${message}`);
+		this.name = "ServerNetworkError";
+	}
+};
+/**
+* Parse error during data handling.
+*
+* Port of `Error::ParseError(String)` from server/error.rs line 10.
+*
+* @category Server Errors
+*/
+var ServerParseError = class extends ServerError {
+	constructor(message) {
+		super(`Parse error: ${message}`);
+		this.name = "ServerParseError";
+	}
+};
+/**
+* SQLite database error.
+*
+* Port of `Error::Sqlite(e)` from server/error.rs line 19.
+*
+* @category Server Errors
+*/
+var SqliteError = class extends ServerError {
+	/** The underlying error */
+	cause;
+	constructor(message, cause) {
+		super(`SQLite error: ${message}`);
+		this.name = "SqliteError";
+		if (cause !== void 0) this.cause = cause;
+	}
+};
+
+//#endregion
+//#region src/server/memory-kv.ts
+/**
+* In-memory key-value store for Gordian Envelopes.
+*
+* Provides volatile storage with TTL support and automatic cleanup of
+* expired entries.
+*
+* Port of `struct MemoryKv` from server/memory_kv.rs lines 14-21.
+*
+* @category Server Backend
+*
+* @example
+* ```typescript
+* const store = new MemoryKv();
+* const arid = ARID.new();
+* const envelope = Envelope.new("Hello, Memory!");
+*
+* await store.put(arid, envelope, 3600); // 1 hour TTL
+* const result = await store.get(arid);
+* ```
+*/
+var MemoryKv = class {
+	storage;
+	/**
+	* Create a new in-memory key-value store.
+	*
+	* Port of `MemoryKv::new()` from server/memory_kv.rs lines 29-33.
+	*/
+	constructor() {
+		this.storage = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Check if an ARID exists and is not expired.
+	*
+	* Port of `check_exists()` from server/memory_kv.rs lines 36-53.
+	*
+	* @internal
+	*/
+	checkExists(arid) {
+		const key = arid.urString();
+		const entry = this.storage.get(key);
+		if (entry) {
+			if (entry.expiresAt !== void 0 && Date.now() >= entry.expiresAt) {
+				this.storage.delete(key);
+				return false;
+			}
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Store an envelope at the given ARID.
+	*
+	* Port of `KvStore::put()` implementation from server/memory_kv.rs lines 62-102.
+	*/
+	async put(arid, envelope, ttlSeconds, verbose) {
+		const key = arid.urString();
+		if (this.storage.has(key)) {
+			if (verbose) verbosePrintln(`PUT ${key} ALREADY_EXISTS`);
+			throw new AlreadyExistsError(key);
+		}
+		const expiresAt = ttlSeconds !== void 0 ? Date.now() + ttlSeconds * 1e3 : void 0;
+		const entry = { envelopeCbor: envelope.taggedCborData() };
+		if (expiresAt !== void 0) entry.expiresAt = expiresAt;
+		this.storage.set(key, entry);
+		if (verbose) verbosePrintln(`PUT ${key}${ttlSeconds !== void 0 ? ` (TTL ${ttlSeconds}s)` : ""} OK (Memory)`);
+		return "Stored in memory";
+	}
+	/**
+	* Retrieve an envelope for the given ARID.
+	*
+	* Port of `KvStore::get()` implementation from server/memory_kv.rs lines 104-181.
+	*/
+	async get(arid, timeoutSeconds, verbose) {
+		const timeout = timeoutSeconds ?? 30;
+		const start = Date.now();
+		let firstAttempt = true;
+		const key = arid.urString();
+		const { EnvelopeDecoder } = await import("@bcts/envelope");
+		while (true) {
+			const entry = this.storage.get(key);
+			if (entry) {
+				if (entry.expiresAt !== void 0 && Date.now() >= entry.expiresAt) {
+					this.storage.delete(key);
+					if (verbose) verbosePrintln(`GET ${key} EXPIRED`);
+					return null;
+				}
+				try {
+					const envelope = EnvelopeDecoder.tryFromCborData(entry.envelopeCbor);
+					if (verbose) verbosePrintln(`GET ${key} OK (Memory)`);
+					return envelope;
+				} catch {
+					return null;
+				}
+			}
+			if ((Date.now() - start) / 1e3 >= timeout) {
+				if (verbose) verbosePrintln(`GET ${key} NOT_FOUND (timeout after ${timeout}s)`);
+				return null;
+			}
+			if (firstAttempt && verbose) {
+				verbosePrintln(`Polling for ${key} (timeout: ${timeout}s)`);
+				firstAttempt = false;
+			} else if (verbose) process.stdout.write(".");
+			await new Promise((resolve) => setTimeout(resolve, 500));
+		}
+	}
+	/**
+	* Check if an envelope exists at the given ARID.
+	*
+	* Port of `KvStore::exists()` implementation from server/memory_kv.rs lines 183-186.
+	*/
+	async exists(arid) {
+		return this.checkExists(arid);
+	}
+};
+
+//#endregion
+//#region src/server/sqlite-kv.ts
+/**
+* SQLite-backed key-value store for Gordian Envelopes.
+*
+* Port of server/sqlite_kv.rs from hubert-rust.
+*
+* @module
+*/
+/**
+* SQLite-backed key-value store for Gordian Envelopes.
+*
+* Provides persistent storage with TTL support and automatic cleanup of
+* expired entries.
+*
+* Port of `struct SqliteKv` from server/sqlite_kv.rs lines 16-24.
+*
+* @category Server Backend
+*
+* @example
+* ```typescript
+* const store = new SqliteKv("./hubert.db");
+* const arid = ARID.new();
+* const envelope = Envelope.new("Hello, SQLite!");
+*
+* await store.put(arid, envelope, 3600); // 1 hour TTL
+* const result = await store.get(arid);
+*
+* // Cleanup when done
+* store.close();
+* ```
+*/
+var SqliteKv = class {
+	db;
+	dbPath;
+	cleanupInterval = null;
+	/**
+	* Create a new SQLite-backed key-value store.
+	*
+	* Port of `SqliteKv::new()` from server/sqlite_kv.rs lines 26-67.
+	*
+	* @param dbPath - Path to the SQLite database file. Will be created if it doesn't exist.
+	* @throws {SqliteError} If database initialization fails
+	*/
+	constructor(dbPath) {
+		this.dbPath = dbPath;
+		const parentDir = path$1.dirname(dbPath);
+		if (parentDir && parentDir !== "." && !fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
+		try {
+			this.db = new Database(dbPath);
+			this.db.exec(`
+        CREATE TABLE IF NOT EXISTS hubert_store (
+          arid TEXT PRIMARY KEY,
+          envelope TEXT NOT NULL,
+          expires_at INTEGER
+        );
+        CREATE INDEX IF NOT EXISTS idx_expires_at ON hubert_store(expires_at);
+      `);
+		} catch (error) {
+			throw new SqliteError(`Failed to initialize database: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : void 0);
+		}
+		this.startCleanupTask();
+	}
+	/**
+	* Start a background task that prunes expired entries every minute.
+	*
+	* Port of `start_cleanup_task()` from server/sqlite_kv.rs lines 70-126.
+	*
+	* @internal
+	*/
+	startCleanupTask() {
+		this.cleanupInterval = setInterval(() => {
+			const now = Math.floor(Date.now() / 1e3);
+			try {
+				const arids = this.db.prepare("SELECT arid FROM hubert_store WHERE expires_at IS NOT NULL AND expires_at <= ?").all(now).map((row) => row.arid);
+				if (arids.length > 0) {
+					this.db.prepare("DELETE FROM hubert_store WHERE expires_at IS NOT NULL AND expires_at <= ?").run(now);
+					const count = arids.length;
+					const aridList = arids.join(" ");
+					verbosePrintln(`Pruned ${count} expired ${count === 1 ? "entry" : "entries"}: ${aridList}`);
+				}
+			} catch {}
+		}, 60 * 1e3);
+	}
+	/**
+	* Check if an ARID exists and is not expired.
+	*
+	* Port of `check_exists()` from server/sqlite_kv.rs lines 129-170.
+	*
+	* @internal
+	*/
+	checkExists(arid) {
+		const aridStr = arid.urString();
+		const now = Math.floor(Date.now() / 1e3);
+		try {
+			const row = this.db.prepare("SELECT expires_at FROM hubert_store WHERE arid = ?").get(aridStr);
+			if (row) {
+				if (row.expires_at !== null && now >= row.expires_at) {
+					this.db.prepare("DELETE FROM hubert_store WHERE arid = ?").run(aridStr);
+					return false;
+				}
+				return true;
+			}
+			return false;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Store an envelope at the given ARID.
+	*
+	* Port of `KvStore::put()` implementation from server/sqlite_kv.rs lines 175-236.
+	*/
+	async put(arid, envelope, ttlSeconds, verbose) {
+		if (this.checkExists(arid)) {
+			if (verbose) verbosePrintln(`PUT ${arid.urString()} ALREADY_EXISTS`);
+			throw new AlreadyExistsError(arid.urString());
+		}
+		const aridStr = arid.urString();
+		const envelopeStr = envelope.urString();
+		const expiresAt = ttlSeconds !== void 0 ? Math.floor(Date.now() / 1e3) + ttlSeconds : null;
+		try {
+			this.db.prepare("INSERT INTO hubert_store (arid, envelope, expires_at) VALUES (?, ?, ?)").run(aridStr, envelopeStr, expiresAt);
+			if (verbose) verbosePrintln(`PUT ${aridStr}${ttlSeconds !== void 0 ? ` (TTL ${ttlSeconds}s)` : ""} OK (SQLite: ${this.dbPath})`);
+			return `Stored in SQLite: ${this.dbPath}`;
+		} catch (error) {
+			throw new SqliteError(`Failed to insert: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : void 0);
+		}
+	}
+	/**
+	* Retrieve an envelope for the given ARID.
+	*
+	* Port of `KvStore::get()` implementation from server/sqlite_kv.rs lines 238-354.
+	*/
+	async get(arid, timeoutSeconds, verbose) {
+		const timeout = timeoutSeconds ?? 30;
+		const start = Date.now();
+		let firstAttempt = true;
+		const aridStr = arid.urString();
+		const { Envelope } = await import("@bcts/envelope");
+		while (true) {
+			const now = Math.floor(Date.now() / 1e3);
+			try {
+				const row = this.db.prepare("SELECT envelope, expires_at FROM hubert_store WHERE arid = ?").get(aridStr);
+				if (row) {
+					if (row.expires_at !== null && now >= row.expires_at) {
+						this.db.prepare("DELETE FROM hubert_store WHERE arid = ?").run(aridStr);
+						if (verbose) verbosePrintln(`GET ${aridStr} EXPIRED`);
+						return null;
+					}
+					const envelope = Envelope.fromUrString(row.envelope);
+					if (verbose) verbosePrintln(`GET ${aridStr} OK (SQLite: ${this.dbPath})`);
+					return envelope;
+				}
+			} catch {}
+			if ((Date.now() - start) / 1e3 >= timeout) {
+				if (verbose) verbosePrintln(`GET ${aridStr} NOT_FOUND (timeout after ${timeout}s)`);
+				return null;
+			}
+			if (firstAttempt && verbose) {
+				verbosePrintln(`Polling for ${aridStr} (timeout: ${timeout}s)`);
+				firstAttempt = false;
+			} else if (verbose) process.stdout.write(".");
+			await new Promise((resolve) => setTimeout(resolve, 500));
+		}
+	}
+	/**
+	* Check if an envelope exists at the given ARID.
+	*
+	* Port of `KvStore::exists()` implementation from server/sqlite_kv.rs lines 356-359.
+	*/
+	async exists(arid) {
+		return this.checkExists(arid);
+	}
+	/**
+	* Close the database connection and stop the cleanup task.
+	*/
+	close() {
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = null;
+		}
+		this.db.close();
+	}
+};
+
+//#endregion
+//#region src/server/server-kv.ts
+/**
+* Create a new in-memory server KV store.
+*
+* Port of `ServerKv::memory()` from server/server_kv.rs line 19.
+*
+* @returns A new MemoryKv instance
+* @category Server Backend
+*/
+function createMemoryKv() {
+	return new MemoryKv();
+}
+/**
+* Create a new SQLite-backed server KV store.
+*
+* Port of `ServerKv::sqlite()` from server/server_kv.rs line 22.
+*
+* @param store - The SqliteKv instance to use
+* @returns The same SqliteKv instance
+* @category Server Backend
+*/
+function createSqliteKv(store) {
+	return store;
+}
+/**
+* Synchronously put an envelope into the store.
+*
+* This function wraps the async KvStore trait implementation for use
+* in synchronous HTTP handlers.
+*
+* Port of `put_sync()` from server/server_kv.rs lines 27-52.
+*
+* @param store - The KvStore to use
+* @param arid - The ARID to store at
+* @param envelope - The envelope to store
+* @param ttlSeconds - TTL in seconds
+* @returns Promise that resolves when storage is complete
+* @internal
+*/
+async function putSync(store, arid, envelope, ttlSeconds) {
+	await store.put(arid, envelope, ttlSeconds, false);
+}
+/**
+* Synchronously get an envelope from the store.
+*
+* This function wraps the async KvStore trait implementation for use
+* in synchronous HTTP handlers.
+*
+* Port of `get_sync()` from server/server_kv.rs lines 58-71.
+*
+* @param store - The KvStore to use
+* @param arid - The ARID to retrieve
+* @returns The envelope if found, or null
+* @internal
+*/
+async function getSync(store, arid) {
+	return await store.get(arid, 0, false);
+}
+
+//#endregion
+//#region src/server/server.ts
+/**
+* Hubert HTTP server implementation.
+*
+* Port of server/server.rs from hubert-rust.
+*
+* @module
+*/
+/**
+* Package version for health endpoint.
+*/
+const VERSION = "1.0.0-alpha.1";
+/**
+* Default server configuration.
+*
+* Port of `impl Default for ServerConfig` from server/server.rs lines 32-40.
+*/
+const defaultServerConfig = {
+	port: 45678,
+	maxTtl: 86400,
+	verbose: false
+};
+/**
+* Shared server state.
+*
+* Port of `struct ServerState` from server/server.rs lines 43-47.
+*
+* @internal
+*/
+var ServerState = class {
+	storage;
+	config;
+	constructor(config, storage) {
+		this.storage = storage;
+		this.config = config;
+	}
+	/**
+	* Put an envelope into storage.
+	*
+	* Port of `ServerState::put()` from server/server.rs lines 54-101.
+	*/
+	async put(arid, envelope, requestedTtl, clientIp) {
+		const maxTtl = this.config.maxTtl;
+		let ttl;
+		if (requestedTtl !== void 0) ttl = requestedTtl > maxTtl ? maxTtl : requestedTtl;
+		else ttl = maxTtl;
+		try {
+			await putSync(this.storage, arid, envelope, ttl);
+			if (this.config.verbose) verbosePrintln(`${clientIp ? `${clientIp}: ` : ""}PUT ${arid.urString()} (TTL ${ttl}s) OK`);
+		} catch (error) {
+			if (this.config.verbose) {
+				const ipStr = clientIp ? `${clientIp}: ` : "";
+				const errorMsg = error instanceof Error ? error.message : String(error);
+				verbosePrintln(`${ipStr}PUT ${arid.urString()} (TTL ${ttl}s) ERROR: ${errorMsg}`);
+			}
+			throw error;
+		}
+	}
+	/**
+	* Get an envelope from storage.
+	*
+	* Port of `ServerState::get()` from server/server.rs lines 103-126.
+	*/
+	async get(arid, clientIp) {
+		const result = await getSync(this.storage, arid);
+		if (this.config.verbose) {
+			const ipStr = clientIp ? `${clientIp}: ` : "";
+			const status = result ? "OK" : "NOT_FOUND";
+			verbosePrintln(`${ipStr}GET ${arid.urString()} ${status}`);
+		}
+		return result;
+	}
+};
+/**
+* Hubert HTTP server.
+*
+* Port of `struct Server` from server/server.rs lines 128-133.
+*
+* @category Server
+*
+* @example
+* ```typescript
+* const server = Server.newMemory({ port: 8080, maxTtl: 3600, verbose: true });
+* await server.run();
+* ```
+*/
+var Server = class Server {
+	config;
+	state;
+	fastify;
+	/**
+	* Create a new server with the given configuration and storage backend.
+	*
+	* Port of `Server::new()` from server/server.rs lines 135-139.
+	*/
+	constructor(config, storage) {
+		this.config = config;
+		this.state = new ServerState(config, storage);
+		this.fastify = Fastify({ logger: false });
+		this.setupRoutes();
+	}
+	/**
+	* Create a new server with in-memory storage.
+	*
+	* Port of `Server::new_memory()` from server/server.rs lines 142-144.
+	*/
+	static newMemory(config = {}) {
+		return new Server({
+			...defaultServerConfig,
+			...config
+		}, new MemoryKv());
+	}
+	/**
+	* Create a new server with SQLite storage.
+	*
+	* Port of `Server::new_sqlite()` from server/server.rs lines 147-149.
+	*/
+	static newSqlite(config = {}, storage) {
+		return new Server({
+			...defaultServerConfig,
+			...config
+		}, storage);
+	}
+	/**
+	* Setup HTTP routes.
+	* @internal
+	*/
+	setupRoutes() {
+		this.fastify.get("/health", this.handleHealth.bind(this));
+		this.fastify.post("/put", this.handlePut.bind(this));
+		this.fastify.post("/get", this.handleGet.bind(this));
+	}
+	/**
+	* Handle health check requests.
+	*
+	* Port of `handle_health()` from server/server.rs lines 179-187.
+	*/
+	async handleHealth(_request, reply) {
+		reply.send({
+			server: "hubert",
+			version: VERSION,
+			status: "ok"
+		});
+	}
+	/**
+	* Handle PUT requests.
+	*
+	* Port of `handle_put()` from server/server.rs lines 195-238.
+	*/
+	async handlePut(request, reply) {
+		try {
+			const bodyStr = request.body;
+			if (typeof bodyStr !== "string") {
+				reply.status(400).send("Expected text body");
+				return;
+			}
+			const lines = bodyStr.split("\n");
+			if (lines.length < 2) {
+				reply.status(400).send("Expected at least 2 lines: ur:arid and ur:envelope");
+				return;
+			}
+			let arid;
+			try {
+				arid = ARID.fromUrString(lines[0]);
+			} catch {
+				reply.status(400).send("Invalid ur:arid");
+				return;
+			}
+			let envelope;
+			try {
+				envelope = Envelope.fromUrString(lines[1]);
+			} catch {
+				reply.status(400).send("Invalid ur:envelope");
+				return;
+			}
+			let ttl;
+			if (lines.length > 2 && lines[2].trim() !== "") {
+				const parsed = parseInt(lines[2], 10);
+				if (isNaN(parsed)) {
+					reply.status(400).send("Invalid TTL");
+					return;
+				}
+				ttl = parsed;
+			}
+			const clientIp = request.ip;
+			await this.state.put(arid, envelope, ttl, clientIp);
+			reply.status(200).send("OK");
+		} catch (error) {
+			if (error instanceof Error && error.name === "AlreadyExistsError") reply.status(409).send(error.message);
+			else reply.status(500).send(error instanceof Error ? error.message : "Internal server error");
+		}
+	}
+	/**
+	* Handle GET requests.
+	*
+	* Port of `handle_get()` from server/server.rs lines 244-269.
+	*/
+	async handleGet(request, reply) {
+		try {
+			const bodyStr = request.body;
+			if (typeof bodyStr !== "string") {
+				reply.status(400).send("Expected text body");
+				return;
+			}
+			const aridStr = bodyStr.trim();
+			if (aridStr === "") {
+				reply.status(400).send("Expected ur:arid");
+				return;
+			}
+			let arid;
+			try {
+				arid = ARID.fromUrString(aridStr);
+			} catch {
+				reply.status(400).send("Invalid ur:arid");
+				return;
+			}
+			const clientIp = request.ip;
+			const envelope = await this.state.get(arid, clientIp);
+			if (envelope) reply.status(200).send(envelope.urString());
+			else reply.status(404).send("Not found");
+		} catch (error) {
+			reply.status(500).send(error instanceof Error ? error.message : "Internal server error");
+		}
+	}
+	/**
+	* Run the server.
+	*
+	* Port of `Server::run()` from server/server.rs lines 152-170.
+	*/
+	async run() {
+		const addr = `127.0.0.1:${this.config.port}`;
+		this.fastify.addContentTypeParser("text/plain", { parseAs: "string" }, (_request, payload, done) => {
+			done(null, payload);
+		});
+		this.fastify.addContentTypeParser("application/octet-stream", { parseAs: "string" }, (_request, payload, done) => {
+			done(null, payload);
+		});
+		await this.fastify.listen({
+			port: this.config.port,
+			host: "127.0.0.1"
+		});
+		console.log(`✓ Hubert server listening on ${addr}`);
+	}
+	/**
+	* Get the port the server is configured to listen on.
+	*
+	* Port of `Server::port()` from server/server.rs line 173.
+	*/
+	port() {
+		return this.config.port;
+	}
+	/**
+	* Stop the server.
+	*/
+	async close() {
+		await this.fastify.close();
+	}
+};
+
+//#endregion
+//#region src/server/kv.ts
+/**
+* Server-backed key-value store using HTTP API.
+*
+* This implementation communicates with a Hubert server via HTTP POST requests.
+*
+* Port of `struct ServerKvClient` from server/kv.rs lines 6-37.
+*
+* @category Server Backend
+*
+* @example
+* ```typescript
+* const store = new ServerKvClient("http://127.0.0.1:45678");
+* const arid = ARID.new();
+* const envelope = Envelope.new("Hello, Server!");
+*
+* // Put envelope (write-once)
+* await store.put(arid, envelope);
+*
+* // Get envelope with verbose logging
+* const retrieved = await store.get(arid, undefined, true);
+* ```
+*/
+var ServerKvClient = class {
+	baseUrl;
+	/**
+	* Create a new server KV store client.
+	*
+	* Port of `ServerKvClient::new()` from server/kv.rs lines 39-46.
+	*
+	* @param baseUrl - Base URL of the Hubert server (e.g., "http://127.0.0.1:45678")
+	*/
+	constructor(baseUrl) {
+		this.baseUrl = baseUrl;
+	}
+	/**
+	* Store an envelope at the given ARID.
+	*
+	* Port of `KvStore::put()` implementation from server/kv.rs lines 67-122.
+	*/
+	async put(arid, envelope, ttlSeconds, verbose) {
+		if (verbose) verbosePrintln("Starting server put operation");
+		let body;
+		if (ttlSeconds !== void 0) body = `${arid.urString()}\n${envelope.urString()}\n${ttlSeconds}`;
+		else body = `${arid.urString()}\n${envelope.urString()}`;
+		if (verbose) verbosePrintln("Sending PUT request to server");
+		try {
+			const response = await fetch(`${this.baseUrl}/put`, {
+				method: "POST",
+				body,
+				headers: { "Content-Type": "text/plain" }
+			});
+			if (response.status === 200) {
+				if (verbose) verbosePrintln("Server put operation completed");
+				return "Stored successfully";
+			} else if (response.status === 409) {
+				if (verbose) verbosePrintln("Server put operation failed");
+				throw new AlreadyExistsError(arid.urString());
+			} else {
+				if (verbose) verbosePrintln("Server put operation failed");
+				throw new ServerGeneralError(await response.text());
+			}
+		} catch (error) {
+			if (error instanceof AlreadyExistsError || error instanceof ServerGeneralError) throw error;
+			throw new ServerNetworkError(error instanceof Error ? error.message : String(error));
+		}
+	}
+	/**
+	* Retrieve an envelope for the given ARID.
+	*
+	* Port of `KvStore::get()` implementation from server/kv.rs lines 124-212.
+	*/
+	async get(arid, timeoutSeconds, verbose) {
+		let printedDot = false;
+		if (verbose) verbosePrintln("Starting server get operation");
+		const timeout = timeoutSeconds ?? 30;
+		const deadline = Date.now() + timeout * 1e3;
+		const pollInterval = 1e3;
+		if (verbose) verbosePrintln("Polling server for value");
+		while (true) {
+			const body = arid.urString();
+			try {
+				const response = await fetch(`${this.baseUrl}/get`, {
+					method: "POST",
+					body,
+					headers: { "Content-Type": "text/plain" }
+				});
+				if (response.status === 200) {
+					if (verbose && printedDot) verboseNewline();
+					if (verbose) verbosePrintln("Value found on server");
+					const envelopeStr = await response.text();
+					try {
+						const envelope = Envelope.fromUrString(envelopeStr);
+						if (verbose) verbosePrintln("Server get operation completed");
+						return envelope;
+					} catch (error) {
+						throw new ServerParseError(error instanceof Error ? error.message : String(error));
+					}
+				} else if (response.status === 404) {
+					if (Date.now() >= deadline) {
+						if (verbose && printedDot) verboseNewline();
+						if (verbose) verbosePrintln("Timeout reached, value not found");
+						return null;
+					}
+					if (verbose) {
+						verbosePrintDot();
+						printedDot = true;
+					}
+					await new Promise((resolve) => setTimeout(resolve, pollInterval));
+				} else throw new ServerGeneralError(await response.text());
+			} catch (error) {
+				if (error instanceof ServerGeneralError || error instanceof ServerParseError) throw error;
+				throw new ServerNetworkError(error instanceof Error ? error.message : String(error));
+			}
+		}
+	}
+	/**
+	* Check if an envelope exists at the given ARID.
+	*
+	* Port of `KvStore::exists()` implementation from server/kv.rs lines 214-218.
+	*/
+	async exists(arid) {
+		return await this.get(arid, 1, false) !== null;
+	}
+};
+
+//#endregion
+export { createSqliteKv as a, ServerError as c, ServerParseError as d, SqliteError as f, createMemoryKv as i, ServerGeneralError as l, Server as n, SqliteKv as o, defaultServerConfig as r, MemoryKv as s, ServerKvClient as t, ServerNetworkError as u };
+//# sourceMappingURL=server-DVyk9gqU.mjs.map