@bcts/hubert 1.0.0-alpha.17

package/dist/index-BEzpUC7r.d.mts

@@ -0,0 +1,380 @@
+import { r as HubertError, t as KvStore } from "./kv-store-DmngWWuw.mjs";
+import { ARID } from "@bcts/components";
+import { Envelope } from "@bcts/envelope";
+
+//#region src/server/error.d.ts
+/**
+ * Base error class for server errors.
+ *
+ * @category Server Errors
+ */
+declare class ServerError extends HubertError {
+  constructor(message: string);
+}
+/**
+ * General server error.
+ *
+ * Port of `Error::General(String)` from server/error.rs line 4.
+ *
+ * @category Server Errors
+ */
+declare class ServerGeneralError extends ServerError {
+  constructor(message: string);
+}
+/**
+ * Network error during server communication.
+ *
+ * Port of `Error::NetworkError(String)` from server/error.rs line 7.
+ *
+ * @category Server Errors
+ */
+declare class ServerNetworkError extends ServerError {
+  constructor(message: string);
+}
+/**
+ * Parse error during data handling.
+ *
+ * Port of `Error::ParseError(String)` from server/error.rs line 10.
+ *
+ * @category Server Errors
+ */
+declare class ServerParseError extends ServerError {
+  constructor(message: string);
+}
+/**
+ * SQLite database error.
+ *
+ * Port of `Error::Sqlite(e)` from server/error.rs line 19.
+ *
+ * @category Server Errors
+ */
+declare class SqliteError extends ServerError {
+  /** The underlying error */
+  readonly cause?: Error;
+  constructor(message: string, cause?: Error);
+}
+//#endregion
+//#region src/server/memory-kv.d.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);
+ * ```
+ */
+declare class MemoryKv implements KvStore {
+  private readonly storage;
+  /**
+   * Create a new in-memory key-value store.
+   *
+   * Port of `MemoryKv::new()` from server/memory_kv.rs lines 29-33.
+   */
+  constructor();
+  /**
+   * Check if an ARID exists and is not expired.
+   *
+   * Port of `check_exists()` from server/memory_kv.rs lines 36-53.
+   *
+   * @internal
+   */
+  private checkExists;
+  /**
+   * Store an envelope at the given ARID.
+   *
+   * Port of `KvStore::put()` implementation from server/memory_kv.rs lines 62-102.
+   */
+  put(arid: ARID, envelope: Envelope, ttlSeconds?: number, verbose?: boolean): Promise<string>;
+  /**
+   * Retrieve an envelope for the given ARID.
+   *
+   * Port of `KvStore::get()` implementation from server/memory_kv.rs lines 104-181.
+   */
+  get(arid: ARID, timeoutSeconds?: number, verbose?: boolean): Promise<Envelope | null>;
+  /**
+   * Check if an envelope exists at the given ARID.
+   *
+   * Port of `KvStore::exists()` implementation from server/memory_kv.rs lines 183-186.
+   */
+  exists(arid: ARID): Promise<boolean>;
+}
+//#endregion
+//#region src/server/sqlite-kv.d.ts
+/**
+ * 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();
+ * ```
+ */
+declare class SqliteKv implements KvStore {
+  private readonly db;
+  private readonly dbPath;
+  private cleanupInterval;
+  /**
+   * 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: string);
+  /**
+   * Start a background task that prunes expired entries every minute.
+   *
+   * Port of `start_cleanup_task()` from server/sqlite_kv.rs lines 70-126.
+   *
+   * @internal
+   */
+  private startCleanupTask;
+  /**
+   * Check if an ARID exists and is not expired.
+   *
+   * Port of `check_exists()` from server/sqlite_kv.rs lines 129-170.
+   *
+   * @internal
+   */
+  private checkExists;
+  /**
+   * Store an envelope at the given ARID.
+   *
+   * Port of `KvStore::put()` implementation from server/sqlite_kv.rs lines 175-236.
+   */
+  put(arid: ARID, envelope: Envelope, ttlSeconds?: number, verbose?: boolean): Promise<string>;
+  /**
+   * Retrieve an envelope for the given ARID.
+   *
+   * Port of `KvStore::get()` implementation from server/sqlite_kv.rs lines 238-354.
+   */
+  get(arid: ARID, timeoutSeconds?: number, verbose?: boolean): Promise<Envelope | null>;
+  /**
+   * Check if an envelope exists at the given ARID.
+   *
+   * Port of `KvStore::exists()` implementation from server/sqlite_kv.rs lines 356-359.
+   */
+  exists(arid: ARID): Promise<boolean>;
+  /**
+   * Close the database connection and stop the cleanup task.
+   */
+  close(): void;
+}
+//#endregion
+//#region src/server/server-kv.d.ts
+/**
+ * Server-side key-value storage backend.
+ *
+ * This type allows selecting between in-memory and SQLite storage
+ * at server setup time.
+ *
+ * Port of `enum ServerKv` from server/server_kv.rs lines 7-15.
+ *
+ * @category Server Backend
+ */
+type ServerKv = MemoryKv | SqliteKv;
+/**
+ * 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
+ */
+declare function createMemoryKv(): 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
+ */
+declare function createSqliteKv(store: SqliteKv): SqliteKv;
+//#endregion
+//#region src/server/server.d.ts
+/**
+ * Configuration for the Hubert server.
+ *
+ * Port of `struct ServerConfig` from server/server.rs lines 19-30.
+ *
+ * @category Server
+ */
+interface ServerConfig {
+  /** Port to listen on */
+  port: number;
+  /**
+   * Maximum TTL in seconds allowed.
+   * If a put() specifies a TTL higher than this, it will be clamped.
+   * If put() specifies None, this value will be used.
+   * Hubert is intended for coordination, not long-term storage.
+   */
+  maxTtl: number;
+  /** Enable verbose logging with timestamps */
+  verbose: boolean;
+}
+/**
+ * Default server configuration.
+ *
+ * Port of `impl Default for ServerConfig` from server/server.rs lines 32-40.
+ */
+declare const defaultServerConfig: ServerConfig;
+/**
+ * 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();
+ * ```
+ */
+declare class Server {
+  private readonly config;
+  private readonly state;
+  private readonly 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: ServerConfig, storage: ServerKv);
+  /**
+   * Create a new server with in-memory storage.
+   *
+   * Port of `Server::new_memory()` from server/server.rs lines 142-144.
+   */
+  static newMemory(config?: Partial<ServerConfig>): Server;
+  /**
+   * Create a new server with SQLite storage.
+   *
+   * Port of `Server::new_sqlite()` from server/server.rs lines 147-149.
+   */
+  static newSqlite(config: Partial<ServerConfig> | undefined, storage: SqliteKv): Server;
+  /**
+   * Setup HTTP routes.
+   * @internal
+   */
+  private setupRoutes;
+  /**
+   * Handle health check requests.
+   *
+   * Port of `handle_health()` from server/server.rs lines 179-187.
+   */
+  private handleHealth;
+  /**
+   * Handle PUT requests.
+   *
+   * Port of `handle_put()` from server/server.rs lines 195-238.
+   */
+  private handlePut;
+  /**
+   * Handle GET requests.
+   *
+   * Port of `handle_get()` from server/server.rs lines 244-269.
+   */
+  private handleGet;
+  /**
+   * Run the server.
+   *
+   * Port of `Server::run()` from server/server.rs lines 152-170.
+   */
+  run(): Promise<void>;
+  /**
+   * Get the port the server is configured to listen on.
+   *
+   * Port of `Server::port()` from server/server.rs line 173.
+   */
+  port(): number;
+  /**
+   * Stop the server.
+   */
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/server/kv.d.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);
+ * ```
+ */
+declare class ServerKvClient implements KvStore {
+  private readonly 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: string);
+  /**
+   * Store an envelope at the given ARID.
+   *
+   * Port of `KvStore::put()` implementation from server/kv.rs lines 67-122.
+   */
+  put(arid: ARID, envelope: Envelope, ttlSeconds?: number, verbose?: boolean): Promise<string>;
+  /**
+   * Retrieve an envelope for the given ARID.
+   *
+   * Port of `KvStore::get()` implementation from server/kv.rs lines 124-212.
+   */
+  get(arid: ARID, timeoutSeconds?: number, verbose?: boolean): Promise<Envelope | null>;
+  /**
+   * Check if an envelope exists at the given ARID.
+   *
+   * Port of `KvStore::exists()` implementation from server/kv.rs lines 214-218.
+   */
+  exists(arid: ARID): Promise<boolean>;
+}
+//#endregion
+export { ServerKv as a, SqliteKv as c, ServerGeneralError as d, ServerNetworkError as f, defaultServerConfig as i, MemoryKv as l, SqliteError as m, Server as n, createMemoryKv as o, ServerParseError as p, ServerConfig as r, createSqliteKv as s, ServerKvClient as t, ServerError as u };
+//# sourceMappingURL=index-BEzpUC7r.d.mts.map

package/dist/index-BEzpUC7r.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BEzpUC7r.d.mts","names":[],"sources":["../src/server/error.ts","../src/server/memory-kv.ts","../src/server/sqlite-kv.ts","../src/server/server-kv.ts","../src/server/server.ts","../src/server/kv.ts"],"mappings":"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"}

package/dist/index-C2F6ugLL.d.mts

@@ -0,0 +1,210 @@
+import { r as HubertError, t as KvStore } from "./kv-store-DmngWWuw.mjs";
+import { ARID } from "@bcts/components";
+import { Envelope } from "@bcts/envelope";
+
+//#region src/mainline/error.d.ts
+/**
+ * Base class for Mainline DHT-specific errors.
+ *
+ * @category Mainline
+ */
+declare class MainlineError extends HubertError {
+  constructor(message: string);
+}
+/**
+ * Value size exceeds DHT limit.
+ *
+ * Port of `Error::ValueTooLarge { size }` from mainline/error.rs line 4-5.
+ *
+ * @category Mainline
+ */
+declare class ValueTooLargeError extends MainlineError {
+  readonly size: number;
+  constructor(size: number);
+}
+/**
+ * DHT operation error.
+ *
+ * Port of `Error::DhtError` from mainline/error.rs line 7-8.
+ *
+ * @category Mainline
+ */
+declare class DhtError extends MainlineError {
+  constructor(message: string);
+}
+/**
+ * Put query error.
+ *
+ * Port of `Error::PutQueryError` from mainline/error.rs line 10-11.
+ *
+ * @category Mainline
+ */
+declare class PutQueryError extends MainlineError {
+  constructor(message: string);
+}
+/**
+ * Decode ID error.
+ *
+ * Port of `Error::DecodeIdError` from mainline/error.rs line 13-14.
+ *
+ * @category Mainline
+ */
+declare class DecodeIdError extends MainlineError {
+  constructor(message: string);
+}
+/**
+ * Put mutable error.
+ *
+ * Port of `Error::PutMutableError` from mainline/error.rs line 16-17.
+ *
+ * @category Mainline
+ */
+declare class PutMutableError extends MainlineError {
+  constructor(message: string);
+}
+/**
+ * I/O error.
+ *
+ * Port of `Error::Io` from mainline/error.rs line 19-20.
+ *
+ * @category Mainline
+ */
+declare class MainlineIoError extends MainlineError {
+  constructor(message: string);
+}
+//#endregion
+//#region src/mainline/kv.d.ts
+/**
+ * Mainline DHT-backed key-value store using ARID-based addressing.
+ *
+ * This implementation uses:
+ * - ARID → ed25519 signing key derivation (deterministic)
+ * - BEP-44 mutable storage (fixed location based on pubkey)
+ * - Mainline DHT (BitTorrent DHT) for decentralized storage
+ * - Write-once semantics (seq=1, put fails if already exists)
+ * - Maximum value size: 1000 bytes (DHT protocol limit)
+ *
+ * Port of `struct MainlineDhtKv` from mainline/kv.rs lines 60-64.
+ *
+ * # Storage Model
+ *
+ * Uses BEP-44 mutable items where:
+ * - Public key derived from ARID (deterministic ed25519)
+ * - Sequence number starts at 1 (write-once)
+ * - Optional salt for namespace separation
+ * - Location fixed by pubkey (not content hash)
+ *
+ * # Requirements
+ *
+ * No external daemon required - the DHT client runs embedded.
+ *
+ * # Size Limits
+ *
+ * The Mainline DHT has a practical limit of ~1KB per value. For larger
+ * envelopes, use `IpfsKv` or `HybridKv` instead.
+ *
+ * @category Mainline Backend
+ *
+ * @example
+ * ```typescript
+ * const store = await MainlineDhtKv.create();
+ * const arid = ARID.new();
+ * const envelope = Envelope.new("Small message");
+ *
+ * // Put envelope (write-once)
+ * await store.put(arid, envelope);
+ *
+ * // Get envelope with verbose logging
+ * const retrieved = await store.get(arid, undefined, true);
+ * ```
+ */
+declare class MainlineDhtKv implements KvStore {
+  private readonly dht;
+  private maxValueSize;
+  private salt;
+  private _isBootstrapped;
+  /**
+   * Private constructor - use `create()` factory method.
+   */
+  private constructor();
+  /**
+   * Check if the DHT is bootstrapped.
+   */
+  get isBootstrapped(): boolean;
+  /**
+   * Create a new Mainline DHT KV store with default settings.
+   *
+   * Port of `MainlineDhtKv::new()` from mainline/kv.rs lines 68-79.
+   */
+  static create(): Promise<MainlineDhtKv>;
+  /**
+   * Set the maximum value size (default: 1000 bytes).
+   *
+   * Note: Values larger than ~1KB may not be reliably stored in the DHT.
+   *
+   * Port of `MainlineDhtKv::with_max_size()` from mainline/kv.rs lines 84-87.
+   */
+  withMaxSize(size: number): this;
+  /**
+   * Set a salt for namespace separation.
+   *
+   * Different salts will create separate namespaces for the same ARID.
+   *
+   * Port of `MainlineDhtKv::with_salt()` from mainline/kv.rs lines 92-95.
+   */
+  withSalt(salt: Uint8Array): this;
+  /**
+   * Derive an ed25519 signing key from an ARID.
+   *
+   * Uses the ARID-derived key material extended to 32 bytes for ed25519.
+   *
+   * Port of `MainlineDhtKv::derive_signing_key()` from mainline/kv.rs lines 100-112.
+   *
+   * @internal
+   */
+  private static deriveSigningKey;
+  /**
+   * Get mutable item from DHT.
+   *
+   * @internal
+   */
+  private getMutable;
+  /**
+   * Put mutable item to DHT.
+   *
+   * @internal
+   */
+  private putMutable;
+  /**
+   * Compute DHT target hash from public key and optional salt.
+   *
+   * @internal
+   */
+  private computeTarget;
+  /**
+   * Store an envelope at the given ARID.
+   *
+   * Port of `KvStore::put()` implementation from mainline/kv.rs lines 144-220.
+   */
+  put(arid: ARID, envelope: Envelope, _ttlSeconds?: number, // Ignored - DHT has no TTL support
+  verbose?: boolean): Promise<string>;
+  /**
+   * Retrieve an envelope for the given ARID.
+   *
+   * Port of `KvStore::get()` implementation from mainline/kv.rs lines 223-303.
+   */
+  get(arid: ARID, timeoutSeconds?: number, verbose?: boolean): Promise<Envelope | null>;
+  /**
+   * Check if an envelope exists at the given ARID.
+   *
+   * Port of `KvStore::exists()` implementation from mainline/kv.rs lines 306-314.
+   */
+  exists(arid: ARID): Promise<boolean>;
+  /**
+   * Destroy the DHT client and release resources.
+   */
+  destroy(): Promise<void>;
+}
+//#endregion
+export { MainlineIoError as a, ValueTooLargeError as c, MainlineError as i, DecodeIdError as n, PutMutableError as o, DhtError as r, PutQueryError as s, MainlineDhtKv as t };
+//# sourceMappingURL=index-C2F6ugLL.d.mts.map

package/dist/index-C2F6ugLL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-C2F6ugLL.d.mts","names":[],"sources":["../src/mainline/error.ts","../src/mainline/kv.ts"],"mappings":";;;;;;;;;;cAea,aAAA,SAAsB,WAAA;cACrB,OAAA;AAAA;;;;;;;;cAaD,kBAAA,SAA2B,aAAA;EAAA,SAC7B,IAAA;cAEG,IAAA;AAAA;;;;;;;AA4Bd;cAda,QAAA,SAAiB,aAAA;cAChB,OAAA;AAAA;;;;;;AA2Bd;;cAda,aAAA,SAAsB,aAAA;cACrB,OAAA;AAAA;;;;;AA2Bd;;;cAda,aAAA,SAAsB,aAAA;cACrB,OAAA;AAAA;;;;AA2Bd;;;;cAda,eAAA,SAAwB,aAAA;cACvB,OAAA;AAAA;;;;;;ACxBd;;cDqCa,eAAA,SAAwB,aAAA;cACvB,OAAA;AAAA;;;;;;;AA1Ed;;;;;;;;;;AAiBA;;;;;;;;;AAcA;;;;;;;;;AAcA;;;;;;;;;AAcA;;;cCvBa,aAAA,YAAyB,OAAA;EAAA,iBACnB,GAAA;EAAA,QACT,YAAA;EAAA,QACA,IAAA;EAAA,QACA,eAAA;EDoBmB;AAa7B;;EAb6B,QCfpB,WAAA,CAAA;ED4ByC;;;EAAA,IClB5C,cAAA,CAAA;EDmBuB;;;;;EAAA,OCVd,MAAA,CAAA,GAAU,OAAA,CAAQ,aAAA;EA5BN;;;;;;;EA6DzB,WAAA,CAAY,IAAA;EAiMI;;;;;;;EArLhB,QAAA,CAAS,IAAA,EAAM,UAAA;EAzE4B;;;;;;;;;EAAA,eAuF5B,gBAAA;EA3DgB;;;;;EAAA,QAiFvB,UAAA;EAtBO;;;;;EAAA,QAyCP,UAAA;EA4DN;;;;;EAAA,QAlBM,aAAA;EAoFF;;;;;EAnEA,GAAA,CACJ,IAAA,EAAM,IAAA,EACN,QAAA,EAAU,QAAA,EACV,WAAA;EACA,OAAA,aACC,OAAA;EAuIG;;;;;EAzEA,GAAA,CAAI,IAAA,EAAM,IAAA,EAAM,cAAA,WAAyB,OAAA,aAAoB,OAAA,CAAQ,QAAA;EAoFzD;;;;;EAXZ,MAAA,CAAO,IAAA,EAAM,IAAA,GAAO,OAAA;;;;EAW1B,OAAA,CAAA,GAAW,OAAA;AAAA"}