@reddb-io/ui 0.3.6 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reddb-io/ui",
-  "version": "0.3.6",
+  "version": "0.4.1",
   "private": false,
   "description": "RedDB UI components and standalone web application.",
   "type": "module",
@@ -47,8 +47,8 @@
   },
   "dependencies": {
     "@aflsolutions/graphology-communities-leiden": "^1.1.1",
-    "@reddb-io/ui-kit": "0.3.6",
-    "@reddb-io/ui-mcp": "0.3.6",
+    "@reddb-io/ui-kit": "0.4.1",
+    "@reddb-io/ui-mcp": "0.4.1",
     "@sigma/edge-curve": "^3.1.0",
     "@sigma/node-border": "^3.0.0",
     "@tauri-apps/api": "^2.5.0",

package/src/lib/ConnectDropdown.svelte

@@ -37,7 +37,7 @@
   let inputEl: HTMLInputElement | undefined = $state()
 
   async function attempt(targetUrl: string, signIn = false) {
-    const cleaned = targetUrl.trim().replace(/\/$/, '')
+    const cleaned = targetUrl.trim()
     if (!cleaned) return
     let parsed: ReturnType<typeof parseConnectionInput>
     const secret = password
@@ -211,7 +211,7 @@
       aria-label="Connect to reddb"
     >
       <form onsubmit={submit}>
-        <label for="connect-url" class="type-label block mb-1.5">Instance URL</label>
+        <label for="connect-url" class="type-label block mb-1.5">Connection string</label>
         <input
           id="connect-url"
           bind:this={inputEl}
@@ -219,11 +219,11 @@
           disabled={status === 'probing'}
           oninput={() => { username = ''; password = '' }}
           spellcheck="false"
-          placeholder="red://localhost"
+          placeholder="https://user:password@host or Base64"
           class="w-full h-9 px-3 mb-1 bg-bg-0 border border-line-2 rounded-md font-mono text-[13px] text-fg-0 outline-none transition-colors focus:border-accent placeholder:text-fg-3"
         />
 
-        <div class="mb-2 text-[10px] font-mono text-fg-3">reachable here: {supportedHint}</div>
+        <div class="mb-2 text-[10px] font-mono text-fg-3">URL or Base64-encoded URL · reachable here: {supportedHint}</div>
 
         <details class="mb-3">
           <summary class="cursor-pointer text-xs text-fg-2">Sign in to the database</summary>

package/src/lib/Workspace.svelte

@@ -21,7 +21,7 @@
   import SecurityView from './SecurityView.svelte'
   import SettingsView from './SettingsView.svelte'
   import Appearance from './Appearance.svelte'
-  import { connection, makeCustomConnection, setConnectionProvider } from './connections.svelte'
+  import { connection, setConnectionProvider } from './connections.svelte'
   import { runQueryPreferStream, type ConnectionProvider } from '#reddb'
   import { theme, type Theme } from './theme.svelte'
   import { skins } from './skins/skins.svelte'
@@ -162,7 +162,7 @@
             if (route) target = raw.split('?')[0]
           } catch {}
 
-          await connection.tryConnect(makeCustomConnection(target))
+          await connection.connectString(target)
           if (route) navigateToBootRoute(route)
         })
       )

package/src/lib/connections.svelte.ts

@@ -9,6 +9,8 @@
 //   - Embedded and managed Web boot targets store nothing.
 
 import {
+  parseConnectionString,
+  type ConnectionCredentials,
   BROWSER_TRANSPORTS,
   DESKTOP_TRANSPORTS,
   DesktopError,
@@ -137,46 +139,18 @@ const historyStore = new SurfaceHistoryStore({
  * host[:port]                 → http://host:port|5055
  */
 export function normalizeUrl(input: string): string {
-  return parseConnectionInput(input).url;
+  if (!input.trim()) return "";
+  return parseConnectionString(input).url;
 }
 
-/** Parse only explicit Connect input; Open Contract URLs still reject secrets. */
-export function parseConnectionInput(input: string): {
-  url: string;
-  credentials?: { username: string; password: string };
-} {
-  let raw = input.trim().replace(/\/$/, "");
-  if (!raw) return { url: raw };
-  if (!/:\/\//.test(raw)) raw = "http://" + raw;
-  const scheme = raw.slice(0, raw.indexOf(":")).toLowerCase();
-  const alias = ["red", "red+tcp", "red+wire", "reds", "red+tls"].includes(
-    scheme
-  );
-  if (!alias && scheme !== "http" && scheme !== "https") return { url: raw };
+/** Backwards-compatible explicit-input API, backed by the shared URI/Base64 parser. */
+export function parseConnectionInput(
+  input: string
+): ReturnType<typeof parseConnectionString> {
+  if (!input.trim()) return { url: "" };
   try {
-    const protocol =
-      scheme === "reds" || scheme === "red+tls" ? "https" : "http";
-    const endpoint = new URL(
-      alias ? raw.replace(/^[^:]+:/, `${protocol}:`) : raw
-    );
-    let credentials: { username: string; password: string } | undefined;
-    if (endpoint.username || endpoint.password) {
-      if (!endpoint.username || !endpoint.password) throw new Error();
-      credentials = {
-        username: decodeURIComponent(endpoint.username),
-        password: decodeURIComponent(endpoint.password),
-      };
-      endpoint.username = "";
-      endpoint.password = "";
-    }
-    // RedWire ports are not HTTP API ports. Keep the UI's existing alias.
-    if (alias) endpoint.port = "5055";
-    return {
-      url: endpoint.href.replace(/\/$/, ""),
-      ...(credentials ? { credentials } : {}),
-    };
+    return parseConnectionString(input);
   } catch {
-    // URL/decode errors can contain the original credential-bearing input.
     throw new Error(
       "Invalid connection string. Check the address and provide both username and password."
     );
@@ -448,8 +422,34 @@ class ConnectionStore {
   ): Promise<string | null> {
     const boot = await resolve();
     const route = boot.route ?? null;
+    if (boot.error) {
+      this.disconnect();
+      this.probe = { reachable: false, error: boot.error };
+      return route;
+    }
     if (!boot.target) return route;
-    const preset = makeCustomConnection(boot.target);
+    if (!boot.token) {
+      await this.connectString(boot.target);
+      return route;
+    }
+    let preset: ConnectionPreset;
+    try {
+      const parsed = parseConnectionString(boot.target);
+      if (parsed.credentials)
+        throw new Error(
+          "Choose either connection credentials or a session token."
+        );
+      preset = makeCustomConnection(parsed.url);
+    } catch (error) {
+      this.disconnect();
+      this.active = makeCustomConnection("");
+      this.probe = {
+        reachable: false,
+        error:
+          error instanceof Error ? error.message : "Invalid connection string.",
+      };
+      return route;
+    }
     if (boot.token) {
       markManagedWebHandoff();
       const provider = getConnectionProvider();
@@ -470,6 +470,39 @@ class ConnectionStore {
     await this.tryConnect(preset);
   }
 
+  /** Accept a plain URI or Base64 URI, keeping credentials out of connection metadata. */
+  async connectString(
+    input: string,
+    credentials?: ConnectionCredentials
+  ): Promise<boolean> {
+    try {
+      const parsed = parseConnectionString(input);
+      if (parsed.credentials && credentials)
+        throw new Error(
+          "Use credentials in either the connection string or the sign-in fields."
+        );
+      const auth = credentials ?? parsed.credentials;
+      const preset = makeCustomConnection(parsed.url);
+      if (!this.canReach(parsed.url))
+        throw new Error(
+          unreachableConnectHint(parsed.url) ??
+            "This connection transport is not available here."
+        );
+      return auth
+        ? await this.login(preset, auth.username, auth.password)
+        : await this.tryConnect(preset);
+    } catch (error) {
+      this.disconnect();
+      this.active = makeCustomConnection("");
+      this.probe = {
+        reachable: false,
+        error:
+          error instanceof Error ? error.message : "Invalid connection string.",
+      };
+      return false;
+    }
+  }
+
   async login(
     preset: ConnectionPreset,
     username: string,
@@ -478,6 +511,7 @@ class ConnectionStore {
     this.active = preset;
     this.#client = null;
     this.connected = false;
+    this.#capabilities = { ...EMPTY_SERVER_CAPABILITIES };
     this.probe = { reachable: false };
     try {
       const targetProvider = getConnectionProvider();
@@ -585,7 +619,7 @@ class ConnectionStore {
     if (!boot) return null;
     const route = boot.to ?? boot.view ?? null;
     if (!boot.endpoint) return route;
-    await this.tryConnect(makeCustomConnection(boot.endpoint));
+    await this.connectString(boot.endpoint);
     return route;
   }
 

package/src/lib/reddb/boot-params.ts

@@ -1,3 +1,8 @@
+import {
+  decodeConnectionString,
+  parseConnectionString,
+} from "./connection-string";
+
 // Open Contract URL pre-configuration. A Surface can seed the loaded Core with
 // a browser-reachable reddb endpoint (`cs`), an initial app route (`to`), and a
 // short-lived token carried only in the URL hash. The Core currently consumes
@@ -6,7 +11,7 @@
 
 /** Parsed Open Contract from the app URL. */
 export interface OpenContract {
-  /** Browser-reachable reddb HTTP endpoint, e.g. `http://host:5055`. */
+  /** Ephemeral plain/Base64 HTTP connection URI; may contain credentials. */
   cs?: string;
   /** Initial app route, e.g. `/cluster` or `/c/users/p/table`. */
   to?: string;
@@ -84,7 +89,7 @@ function looksLikeFilesystemPath(value: string): boolean {
 }
 
 function normalizeCs(input: string): string {
-  const cs = input.trim().replace(/\/$/, "");
+  const cs = input.trim();
   if (!cs) throw new OpenContractError("EMPTY_CS", "Open Contract cs is empty");
   if (looksLikeFilesystemPath(cs)) {
     throw new OpenContractError(
@@ -93,32 +98,19 @@ function normalizeCs(input: string): string {
     );
   }
 
-  let url: URL;
   try {
-    url = new URL(cs);
+    const decoded = decodeConnectionString(cs);
+    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(decoded)) throw new Error();
+    if (looksLikeFilesystemPath(decoded)) throw new Error();
+    const parsed = parseConnectionString(decoded);
+    if (!/^https?:\/\//.test(parsed.url)) throw new Error();
   } catch {
     throw new OpenContractError(
       "MALFORMED_URL",
-      "Open Contract cs is not a valid URL"
-    );
-  }
-
-  if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new OpenContractError(
-      "UNSUPPORTED_SCHEME",
-      "Open Contract cs must use http:// or https://"
+      "Enter a valid HTTP connection string or its Base64 encoding."
     );
   }
 
-  for (const key of url.searchParams.keys()) {
-    if (SECRET_KEY.test(key)) {
-      throw new OpenContractError(
-        "SECRET_IN_CS",
-        "Open Contract secrets must be carried in the app URL hash, not inside cs"
-      );
-    }
-  }
-
   return cs;
 }
 
@@ -164,7 +156,7 @@ export function parseOpenContract(
   );
   const out: OpenContract = {};
 
-  const cs = query.get(CS_KEY);
+  const cs = hashParams.get(CS_KEY) ?? query.get(CS_KEY);
   if (cs !== null) out.cs = normalizeCs(cs);
 
   const to = query.get(TO_KEY);
@@ -176,12 +168,16 @@ export function parseOpenContract(
   return out;
 }
 
-/** Encode the public Open Contract, carrying `token` only in the hash. */
+/** Encode Open Contract; credentials and tokens belong only in the fragment. */
 export function encodeOpenContract(contract: OpenContract): string {
   const query = new URLSearchParams();
   const hash = new URLSearchParams();
 
-  if (contract.cs) query.set(CS_KEY, normalizeCs(contract.cs));
+  if (contract.cs) {
+    const cs = normalizeCs(contract.cs);
+    const parsed = parseConnectionString(cs);
+    (parsed.credentials ? hash : query).set(CS_KEY, cs);
+  }
   if (contract.to) query.set(TO_KEY, normalizeRoute(contract.to));
   if (contract.token) hash.set(TOKEN_KEY, contract.token);
 
@@ -200,10 +196,12 @@ export function parseBootParams(search: string, hash = ""): BootParams {
   const params = new URLSearchParams(search ?? "");
   const out: BootParams = {};
 
-  const cs = params.get(CS_KEY);
+  const cs =
+    new URLSearchParams(hash.replace(/^#/, "")).get(CS_KEY) ??
+    params.get(CS_KEY);
   if (cs !== null) {
     try {
-      out.endpoint = normalizeCs(cs);
+      out.endpoint = parseConnectionString(normalizeCs(cs)).url;
     } catch {
       // Invalid Open Contract endpoints are rejected by omitting the endpoint;
       // the full parser still throws for callers that need diagnostics.
@@ -223,7 +221,12 @@ export function parseBootParams(search: string, hash = ""): BootParams {
     if (out.endpoint) break;
     const v = params.get(key);
     if (v && !SECRET_KEY.test(key)) {
-      out.endpoint = v;
+      try {
+        const parsed = parseConnectionString(v);
+        out.endpoint = parsed.credentials ? parsed.url : v;
+      } catch {
+        /* Invalid legacy endpoint: omit. */
+      }
       break;
     }
   }

package/src/lib/reddb/client.ts

@@ -223,17 +223,10 @@ function isUnsupportedCollectionMetadataRoute(e: unknown): boolean {
   return message.includes("route not found: GET /collections/");
 }
 
-/**
- * Generalised "the server doesn't have this route" check (#22). `json()`
- * throws `<METHOD> <path> → <status> <body>`, so a 404 or a "route not found"
- * body both signal an unsupported route. Distinct from auth/5xx/network errors
- * — but capability negotiation treats *any* probe failure as unsupported
- * (fail safe), so this is only used to tell "route absent" from "signal
- * present" when reading the stable `/capabilities` endpoint.
- */
+/** Missing or unimplemented discovery routes may use compatibility probes. */
 function isUnsupportedRoute(e: unknown): boolean {
   const message = e instanceof Error ? e.message : String(e);
-  return / → 404\b/.test(message) || message.includes("route not found");
+  return / → (404|405|501)\b/.test(message);
 }
 
 function unsupportedCollectionMetadataError(baseUrl: string): Error {
@@ -586,17 +579,30 @@ export class RedClient {
 
   /**
    * Resolve the server's capability map (#22). Prefers the stable
-   * `/capabilities` signal; when that route is absent (older server), infers
-   * from lightweight, side-effect-free GET probes. Any non-404 failure
-   * (network, auth, 5xx) fails safe to the empty map, so the UI hides controls
+   * `/capabilities` signal; when that route is absent or returns structured
+   * discovery without UI feature flags, infers from lightweight, side-effect-free
+   * GET probes. Compatibility follows working APIs, not the server version.
+   * Other failures (network, authentication, unexpected HTTP status) fail safe
+   * to the empty map, so the UI hides controls
    * rather than showing ones the server can't honour.
    */
   async capabilities(): Promise<ServerCapabilities> {
     try {
       const raw = await this.json<RawCapabilities>("/capabilities");
-      return capabilitiesFromSignal(raw);
+      if (
+        !raw ||
+        typeof raw !== "object" ||
+        Array.isArray(raw) ||
+        raw.ok === false
+      )
+        return { ...EMPTY_SERVER_CAPABILITIES };
+      // A flat declaration is authoritative, including explicit false/empty
+      // flags. Structured discovery reports build/deployment state instead;
+      // prove optional UI routes with read-only probes before enabling them.
+      if ("features" in raw || "capabilities" in raw)
+        return capabilitiesFromSignal(raw);
     } catch (e) {
-      // Only an absent route falls through to inference; anything else (a
+      // Only an absent/unimplemented route falls through; anything else (a
       // flaky network, an auth wall, a 5xx) hides everything.
       if (!isUnsupportedRoute(e)) return { ...EMPTY_SERVER_CAPABILITIES };
     }

package/src/lib/reddb/connection-bootstrap.ts

@@ -1,9 +1,11 @@
+import { parseConnectionString } from "./connection-string";
 import { parseOpenContract } from "./boot-params";
 
 export const DEFAULT_PERSISTED_CONNECTION_KEY = "red-ui:connection";
 
 export interface ConnectionBootstrap {
   target: string | null;
+  error?: string;
   token?: string;
   route?: string;
 }
@@ -11,6 +13,7 @@ export interface ConnectionBootstrap {
 export type ConnectionBootstrapPayload =
   | {
       target?: unknown;
+      error?: unknown;
       token?: unknown;
       route?: unknown;
     }
@@ -70,11 +73,13 @@ function normalizeBootstrap(
   const target = clean(payload.target);
   const token = clean(payload.token);
   const route = clean(payload.route);
+  const error = clean(payload.error);
 
-  if (!target && !token && !route) return null;
+  if (!target && !token && !route && !error) return null;
 
   return {
     target: target ?? null,
+    ...(error ? { error } : {}),
     ...(token ? { token } : {}),
     ...(route ? { route } : {}),
   };
@@ -170,25 +175,58 @@ function liveUrlBootstrapOptions(): UrlBootstrapReadOptions {
   };
 }
 
-function stripTokenFromHistory(options: UrlBootstrapReadOptions): void {
+function stripSecretsFromHistory(options: UrlBootstrapReadOptions): void {
   if (!options.consume || !options.location || !options.history) return;
-  const hash = options.location.hash;
-  if (!hash) return;
-
-  const params = new URLSearchParams(
-    hash.startsWith("#") ? hash.slice(1) : hash
-  );
-  if (!params.has("token")) return;
-  params.delete("token");
-
-  const nextHash = params.toString();
-  const nextUrl = `${options.location.pathname}${options.location.search}${
-    nextHash ? `#${nextHash}` : ""
-  }`;
+  const { pathname, search, hash } = options.location;
+  const query = new URLSearchParams(search);
+  const fragment = new URLSearchParams(hash.replace(/^#/, ""));
+  let queryChanged = false;
+  let hashChanged = false;
+  for (const [params, isHash] of [
+    [query, false],
+    [fragment, true],
+  ] as const) {
+    for (const key of [...params.keys()]) {
+      if (
+        /token|secret|password|passwd|auth|credential|api[-_]?key|bearer/i.test(
+          key
+        )
+      ) {
+        params.delete(key);
+        if (isHash) hashChanged = true;
+        else queryChanged = true;
+      }
+    }
+    for (const key of ["cs", "endpoint", "connection", "red_url", "red"]) {
+      const value = params.get(key);
+      if (value === null) continue;
+      let safe: string | undefined;
+      try {
+        if (key === "cs") parseOpenContract(`?cs=${encodeURIComponent(value)}`);
+        safe = parseConnectionString(value).url;
+      } catch {
+        /* Remove invalid input. */
+      }
+      // Fragment connections are single-use; query connections retain only their endpoint.
+      if (isHash || safe !== value) {
+        params.delete(key);
+        if (!isHash && safe) params.set(key, safe);
+        if (isHash) hashChanged = true;
+        else queryChanged = true;
+      }
+    }
+  }
+  if (!queryChanged && !hashChanged) return;
+  const q = queryChanged ? (query.size ? `?${query}` : "") : search;
+  const h = hashChanged ? (fragment.size ? `#${fragment}` : "") : hash;
   try {
-    options.history.replaceState(options.history.state, "", nextUrl);
+    options.history.replaceState(
+      options.history.state,
+      "",
+      `${pathname}${q}${h}`
+    );
   } catch {
-    /* best-effort URL cleanup */
+    /* Best-effort cleanup in restricted embedding contexts. */
   }
 }
 
@@ -199,7 +237,7 @@ export function readUrlOpenContractBootstrap(
 ): ConnectionBootstrapPayload {
   try {
     const contract = parseOpenContract(search, hash);
-    if (contract.token) stripTokenFromHistory(options);
+
     if (!contract.cs && !contract.to && !contract.token) return null;
     return {
       target: contract.cs,
@@ -207,7 +245,12 @@ export function readUrlOpenContractBootstrap(
       route: contract.to,
     };
   } catch {
-    return null;
+    // An explicit invalid contract must not silently fall through to an old database.
+    return {
+      error: "Enter a valid HTTP connection string or its Base64 encoding.",
+    };
+  } finally {
+    stripSecretsFromHistory(options);
   }
 }
 

package/src/lib/reddb/connection-string.ts

@@ -0,0 +1,108 @@
+/** Connection input is ephemeral; only `url` may become connection metadata. */
+export interface ConnectionCredentials {
+  username: string;
+  password: string;
+}
+export interface ParsedConnectionString {
+  url: string;
+  credentials?: ConnectionCredentials;
+}
+export class ConnectionStringError extends Error {
+  constructor(
+    message = "Enter a valid connection URL or its Base64 encoding."
+  ) {
+    super(message);
+    this.name = "ConnectionStringError";
+  }
+}
+const MAX_INPUT_LENGTH = 16_384;
+const SECRET_KEY =
+  /token|secret|password|passwd|auth|credential|api[-_]?key|bearer/i;
+
+/** Decode exactly one layer, accepting standard Base64 and Base64url, with or without padding. */
+export function decodeConnectionString(input: string): string {
+  const raw = input.trim();
+  if (!raw || raw.length > MAX_INPUT_LENGTH) throw new ConnectionStringError();
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) return raw;
+  const prefixed = /^base64(?:url)?:/i.test(raw);
+  const value = prefixed ? raw.replace(/^base64(?:url)?:/i, "") : raw;
+  // Hostnames with a dot or host:port are unambiguous plain inputs.
+  if (!prefixed && !/^[\w+/=-]+$/.test(value)) return raw;
+  let decodedText = false;
+  try {
+    if (!/^[A-Za-z0-9+/_-]+={0,2}$/.test(value)) throw new Error();
+    const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+    const unpadded = normalized.replace(/=+$/, "");
+    if (
+      unpadded.length % 4 === 1 ||
+      (normalized.includes("=") && normalized.length % 4 !== 0)
+    )
+      throw new Error();
+    const binary = atob(unpadded + "=".repeat((4 - (unpadded.length % 4)) % 4));
+    if (btoa(binary).replace(/=+$/, "") !== unpadded) throw new Error();
+    const decoded = new TextDecoder("utf-8", { fatal: true }).decode(
+      Uint8Array.from(binary, (char) => char.charCodeAt(0))
+    );
+    decodedText = true;
+    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(decoded)) throw new Error();
+    return decoded;
+  } catch {
+    // Undotted DNS labels are also valid plain inputs. A successfully decoded
+    // non-URI is rejected (including double encoding), rather than retried.
+    if (
+      !prefixed &&
+      !decodedText &&
+      /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i.test(raw)
+    )
+      return raw;
+    throw new ConnectionStringError();
+  }
+}
+
+/** Browser connections use HTTP. RedWire aliases retain the existing HTTP bridge port convention. */
+export function parseConnectionString(input: string): ParsedConnectionString {
+  let raw = decodeConnectionString(input);
+  if (/^(file|unix|red\+unix):\/\//i.test(raw)) return { url: raw };
+  if (!raw.includes("://")) raw = "http://" + raw;
+  const match = /^([a-z][a-z0-9+.-]*):\/\/(.+)$/i.exec(raw);
+  if (!match) throw new ConnectionStringError();
+  const scheme = match[1].toLowerCase();
+  const wire = ["red", "red+tcp", "red+wire", "reds", "red+tls"].includes(
+    scheme
+  );
+  const secure = ["https", "reds", "red+tls", "red+https"].includes(scheme);
+  if (!wire && !["http", "https", "red+http", "red+https"].includes(scheme)) {
+    throw new ConnectionStringError(
+      "This connection requires an HTTP or HTTPS endpoint."
+    );
+  }
+  try {
+    const url = new URL(`${secure ? "https" : "http"}://${match[2]}`);
+    if (!url.hostname || /\s/.test(url.hostname) || url.hash) throw new Error();
+    for (const key of url.searchParams.keys())
+      if (SECRET_KEY.test(key)) {
+        throw new ConnectionStringError(
+          "Use URI credentials or the sign-in fields, not secrets in query parameters."
+        );
+      }
+    let credentials: ConnectionCredentials | undefined;
+    if (url.username || url.password) {
+      if (!url.username || !url.password)
+        throw new ConnectionStringError(
+          "A connection string needs both a username and a password."
+        );
+      credentials = {
+        username: decodeURIComponent(url.username),
+        password: decodeURIComponent(url.password),
+      };
+      url.username = "";
+      url.password = "";
+    }
+    if (wire) url.port = "5055";
+    const endpoint = url.href.replace(/\/$/, "");
+    return { url: endpoint, ...(credentials ? { credentials } : {}) };
+  } catch (error) {
+    if (error instanceof ConnectionStringError) throw error;
+    throw new ConnectionStringError();
+  }
+}

package/src/lib/reddb/index.ts

@@ -17,3 +17,5 @@ export * from "./secure-store";
 export * from "./web-encrypted-store";
 export * from "./tauri-encrypted-store";
 export * from "./desktop-error";
+
+export * from "./connection-string";