@bcts/hubert 1.0.0-alpha.17

package/dist/server-BBNRZ30D.cjs

@@ -0,0 +1,912 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+const require_logging = require('./logging-qc9uMgil.cjs');
+let better_sqlite3 = require("better-sqlite3");
+better_sqlite3 = require_chunk.__toESM(better_sqlite3);
+let fs = require("fs");
+fs = require_chunk.__toESM(fs);
+let path = require("path");
+path = require_chunk.__toESM(path);
+let fastify = require("fastify");
+fastify = require_chunk.__toESM(fastify);
+let _bcts_components = require("@bcts/components");
+let _bcts_envelope = require("@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 require_logging.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) require_logging.verbosePrintln(`PUT ${key} ALREADY_EXISTS`);
+			throw new require_logging.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) require_logging.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) require_logging.verbosePrintln(`GET ${key} EXPIRED`);
+					return null;
+				}
+				try {
+					const envelope = EnvelopeDecoder.tryFromCborData(entry.envelopeCbor);
+					if (verbose) require_logging.verbosePrintln(`GET ${key} OK (Memory)`);
+					return envelope;
+				} catch {
+					return null;
+				}
+			}
+			if ((Date.now() - start) / 1e3 >= timeout) {
+				if (verbose) require_logging.verbosePrintln(`GET ${key} NOT_FOUND (timeout after ${timeout}s)`);
+				return null;
+			}
+			if (firstAttempt && verbose) {
+				require_logging.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.dirname(dbPath);
+		if (parentDir && parentDir !== "." && !fs.existsSync(parentDir)) fs.mkdirSync(parentDir, { recursive: true });
+		try {
+			this.db = new better_sqlite3.default(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(" ");
+					require_logging.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) require_logging.verbosePrintln(`PUT ${arid.urString()} ALREADY_EXISTS`);
+			throw new require_logging.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) require_logging.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) require_logging.verbosePrintln(`GET ${aridStr} EXPIRED`);
+						return null;
+					}
+					const envelope = Envelope.fromUrString(row.envelope);
+					if (verbose) require_logging.verbosePrintln(`GET ${aridStr} OK (SQLite: ${this.dbPath})`);
+					return envelope;
+				}
+			} catch {}
+			if ((Date.now() - start) / 1e3 >= timeout) {
+				if (verbose) require_logging.verbosePrintln(`GET ${aridStr} NOT_FOUND (timeout after ${timeout}s)`);
+				return null;
+			}
+			if (firstAttempt && verbose) {
+				require_logging.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) require_logging.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);
+				require_logging.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";
+			require_logging.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 = (0, fastify.default)({ 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 = _bcts_components.ARID.fromUrString(lines[0]);
+			} catch {
+				reply.status(400).send("Invalid ur:arid");
+				return;
+			}
+			let envelope;
+			try {
+				envelope = _bcts_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 = _bcts_components.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) require_logging.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) require_logging.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) require_logging.verbosePrintln("Server put operation completed");
+				return "Stored successfully";
+			} else if (response.status === 409) {
+				if (verbose) require_logging.verbosePrintln("Server put operation failed");
+				throw new require_logging.AlreadyExistsError(arid.urString());
+			} else {
+				if (verbose) require_logging.verbosePrintln("Server put operation failed");
+				throw new ServerGeneralError(await response.text());
+			}
+		} catch (error) {
+			if (error instanceof require_logging.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) require_logging.verbosePrintln("Starting server get operation");
+		const timeout = timeoutSeconds ?? 30;
+		const deadline = Date.now() + timeout * 1e3;
+		const pollInterval = 1e3;
+		if (verbose) require_logging.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) require_logging.verboseNewline();
+					if (verbose) require_logging.verbosePrintln("Value found on server");
+					const envelopeStr = await response.text();
+					try {
+						const envelope = _bcts_envelope.Envelope.fromUrString(envelopeStr);
+						if (verbose) require_logging.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) require_logging.verboseNewline();
+						if (verbose) require_logging.verbosePrintln("Timeout reached, value not found");
+						return null;
+					}
+					if (verbose) {
+						require_logging.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
+Object.defineProperty(exports, 'MemoryKv', {
+  enumerable: true,
+  get: function () {
+    return MemoryKv;
+  }
+});
+Object.defineProperty(exports, 'Server', {
+  enumerable: true,
+  get: function () {
+    return Server;
+  }
+});
+Object.defineProperty(exports, 'ServerError', {
+  enumerable: true,
+  get: function () {
+    return ServerError;
+  }
+});
+Object.defineProperty(exports, 'ServerGeneralError', {
+  enumerable: true,
+  get: function () {
+    return ServerGeneralError;
+  }
+});
+Object.defineProperty(exports, 'ServerKvClient', {
+  enumerable: true,
+  get: function () {
+    return ServerKvClient;
+  }
+});
+Object.defineProperty(exports, 'ServerNetworkError', {
+  enumerable: true,
+  get: function () {
+    return ServerNetworkError;
+  }
+});
+Object.defineProperty(exports, 'ServerParseError', {
+  enumerable: true,
+  get: function () {
+    return ServerParseError;
+  }
+});
+Object.defineProperty(exports, 'SqliteError', {
+  enumerable: true,
+  get: function () {
+    return SqliteError;
+  }
+});
+Object.defineProperty(exports, 'SqliteKv', {
+  enumerable: true,
+  get: function () {
+    return SqliteKv;
+  }
+});
+Object.defineProperty(exports, 'createMemoryKv', {
+  enumerable: true,
+  get: function () {
+    return createMemoryKv;
+  }
+});
+Object.defineProperty(exports, 'createSqliteKv', {
+  enumerable: true,
+  get: function () {
+    return createSqliteKv;
+  }
+});
+Object.defineProperty(exports, 'defaultServerConfig', {
+  enumerable: true,
+  get: function () {
+    return defaultServerConfig;
+  }
+});
+//# sourceMappingURL=server-BBNRZ30D.cjs.map