@ultrst-armada/kloks 1.2.1 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultrst-armada/kloks",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "private": false,
   "publishConfig": {
     "access": "public",

package/packages/backend/dist/chunk-BM4QMVPA.js

@@ -0,0 +1,338 @@
+import {
+  createService,
+  createServiceDefinition,
+  createServiceProxy
+} from "./chunk-IPP4VURQ.js";
+
+// src/services/ServiceBoundary.ts
+function createLocalService(definition) {
+  return createService(createServiceDefinition(definition));
+}
+function createRemoteService(definition, adapter, endpoint) {
+  return createServiceProxy(definition, adapter, endpoint);
+}
+
+// src/services/CompositeBackend.ts
+var CompositeBackend = class {
+  id;
+  name;
+  version;
+  services = /* @__PURE__ */ new Map();
+  capabilitiesList = [];
+  constructor(name, version = "1.0.0") {
+    this.name = name;
+    this.id = `backend-${name}`;
+    this.version = version;
+  }
+  registerService(service) {
+    this.services.set(service.name, service);
+    return this;
+  }
+  getService(name) {
+    return this.services.get(name);
+  }
+  getServices() {
+    return Array.from(this.services.values());
+  }
+  registerCapability(capability) {
+    if (!this.capabilitiesList.includes(capability)) {
+      this.capabilitiesList.push(capability);
+    }
+    return this;
+  }
+  async start() {
+    for (const service of this.services.values()) {
+      await service.start();
+    }
+  }
+  async stop() {
+    for (const service of this.services.values()) {
+      await service.stop();
+    }
+  }
+  async call(op, input, ctx) {
+    const firstDot = op.indexOf(".");
+    if (firstDot === -1) {
+      throw new Error(`[CompositeBackend] Invalid operation '${op}'. Expected 'service.operation'.`);
+    }
+    const serviceName = op.slice(0, firstDot);
+    const operationName = op.slice(firstDot + 1);
+    const service = this.services.get(serviceName);
+    if (!service) {
+      throw new Error(`[CompositeBackend] Service '${serviceName}' not registered in '${this.name}'.`);
+    }
+    return await service.call(operationName, input, ctx);
+  }
+  getState() {
+    const aggregated = {};
+    for (const [name, service] of this.services) {
+      aggregated[name] = service.getState();
+    }
+    return Object.freeze(aggregated);
+  }
+  setState(_mutation) {
+  }
+  on(event, handler) {
+    const [serviceName, eventName] = event.split(".");
+    const service = this.services.get(serviceName);
+    if (!service) return () => {
+    };
+    return service.on(eventName, handler);
+  }
+  emit(event, payload) {
+    const [serviceName, eventName] = event.split(".");
+    const service = this.services.get(serviceName);
+    if (service) {
+      service.emit(eventName, payload);
+    }
+  }
+  getDefinition() {
+    const ops = {};
+    for (const service of this.services.values()) {
+      const def = service.getDefinition();
+      for (const [opKey, opDef] of Object.entries(def.operations)) {
+        ops[`${service.name}.${opKey}`] = opDef;
+      }
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      version: this.version,
+      operations: ops,
+      capabilities: this.capabilitiesList.map((c) => ({
+        id: c,
+        name: c,
+        protocols: ["http", "ws", "udp", "p2p"]
+      })),
+      protocols: ["http", "ws", "udp", "p2p"]
+    };
+  }
+};
+
+// src/services/EndpointGenerator.ts
+var EndpointGenerator = class {
+  static generateEndpoints(backend, basePort = 8e3) {
+    const def = backend.getDefinition();
+    const ops = Object.keys(def.operations);
+    return {
+      httpRoutes: ops.map((op) => `/api/${op.replace(".", "/")}`),
+      wsChannels: ops.map((op) => `channel:${op}`),
+      udpEndpoints: [`udp://127.0.0.1:${basePort}`],
+      p2pBindings: ops.map((op) => `p2p://${backend.name}/${op}`)
+    };
+  }
+  static generateDescriptors(backend, host = "127.0.0.1", port = 8080) {
+    return [
+      { protocol: "http", address: host, port, capabilities: ["requestResponse"] },
+      { protocol: "ws", address: host, port, capabilities: ["requestResponse", "pubSub"] },
+      { protocol: "udp", address: host, port, capabilities: ["datagram"] },
+      { protocol: "p2p", address: `p2p://${backend.name}`, capabilities: ["peerToPeer"] }
+    ];
+  }
+};
+
+// src/services/ServiceGenerators.ts
+function createBackend(name) {
+  return new CompositeBackend(name);
+}
+function createCompositeService(name) {
+  return new CompositeBackend(name);
+}
+
+// src/services/nodeGraphPersistence/types.ts
+var LOCAL_STORAGE_GRAPHS_PREFIX = "depm_graph_doc_";
+
+// src/services/nodeGraphPersistence/helpers.ts
+function validateGraphDocument(data) {
+  const errors = [];
+  if (!data || typeof data !== "object") {
+    return { valid: false, errors: ["Invalid JSON: payload must be a JSON object"] };
+  }
+  if (!data.appId) errors.push("Missing required property: appId");
+  if (!data.appName) errors.push("Missing required property: appName");
+  if (!data.graph || typeof data.graph !== "object") {
+    errors.push("Missing or invalid property: graph");
+  } else {
+    if (!Array.isArray(data.graph.nodes)) errors.push("Missing or invalid property: graph.nodes (must be array)");
+    if (!Array.isArray(data.graph.edges)) errors.push("Missing or invalid property: graph.edges (must be array)");
+  }
+  if (errors.length > 0) {
+    return { valid: false, errors };
+  }
+  return {
+    valid: true,
+    errors: [],
+    document: data
+  };
+}
+function exportGraphAsJsonFile(graphDoc) {
+  if (typeof window === "undefined") return;
+  const jsonString = JSON.stringify(graphDoc, null, 2);
+  const blob = new Blob([jsonString], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const safeName = (graphDoc.appName || "graph").toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+  const filename = `${safeName}_${graphDoc.appId}.graph.json`;
+  const link = window.document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  window.document.body.appendChild(link);
+  link.click();
+  window.document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+async function parseGraphJsonFile(file) {
+  try {
+    const text = await file.text();
+    const parsed = JSON.parse(text);
+    return validateGraphDocument(parsed);
+  } catch (err) {
+    return {
+      valid: false,
+      errors: [`Failed to parse JSON: ${err.message}`]
+    };
+  }
+}
+
+// src/services/nodeGraphPersistence/nodeGraphPersistence.ts
+var NodeGraphPersistenceService = class {
+  /**
+   * Generates a fully compliant v1.0.0 JSON document representing the app's complete node graph.
+   */
+  createGraphDocument(options) {
+    const { app, nodes, edges, deployments = [], viewport, storageConnection } = options;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const targetProvider = storageConnection?.provider || "local_fs";
+    const targetBucketOrFolder = storageConnection?.localFolderName || storageConnection?.b2BucketName || storageConnection?.s3BucketName || storageConnection?.r2BucketName || storageConnection?.supabaseBucketName || "Vault";
+    const safeAppName = (app.name || "graph").toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+    const filePath = `graphs/${safeAppName}_${app.id}.graph.json`;
+    return {
+      $schema: "https://skipo.dev/schemas/depm-node-graph.v1.json",
+      version: "1.0.0",
+      appId: app.id,
+      appName: app.name,
+      appIcon: app.icon || "Layers",
+      description: app.description,
+      publicLink: app.publicLink || `https://${safeAppName}.ecosystem.network`,
+      createdAt: app.createdAt || now,
+      updatedAt: now,
+      exportedAt: now,
+      viewport: viewport || { zoom: 1, pan: { x: 0, y: 0 } },
+      graph: {
+        nodes: nodes.filter((n) => !n.appId || n.appId === app.id),
+        edges: edges.filter((e) => !e.appId || e.appId === app.id)
+      },
+      deployments: deployments.filter(
+        (d) => nodes.some((n) => (!n.appId || n.appId === app.id) && n.deploymentId === d.id)
+      ),
+      storageMetadata: {
+        provider: targetProvider,
+        targetName: targetBucketOrFolder,
+        targetPath: filePath,
+        storageConnectionId: storageConnection?.id,
+        syncedAt: now
+      }
+    };
+  }
+  /**
+   * Validates a parsed JSON object to verify it matches the NodeGraphDocument schema.
+   */
+  validateGraphDocument(data) {
+    return validateGraphDocument(data);
+  }
+  /**
+   * Saves the node graph to the selected user storage option (Local Folder or Cloud Bucket)
+   * and caches it in LocalStorage.
+   */
+  async saveGraphToStorage(options, customDirectoryHandle) {
+    const document = this.createGraphDocument(options);
+    const jsonString = JSON.stringify(document, null, 2);
+    const provider = options.storageConnection?.provider || "local_fs";
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        window.localStorage.setItem(`${LOCAL_STORAGE_GRAPHS_PREFIX}${document.appId}`, jsonString);
+        window.localStorage.setItem(`depm_latest_saved_graph_${document.appId}`, JSON.stringify({
+          updatedAt: document.updatedAt,
+          provider,
+          targetName: document.storageMetadata?.targetName
+        }));
+      }
+    } catch {
+    }
+    if (provider === "local_fs" && typeof window !== "undefined") {
+      try {
+        if (customDirectoryHandle) {
+          const fileName = `${(document.appName || "graph").toLowerCase().replace(/[^a-z0-9_-]/g, "_")}_${document.appId}.graph.json`;
+          const fileHandle = await customDirectoryHandle.getFileHandle(fileName, { create: true });
+          const writable = await fileHandle.createWritable();
+          await writable.write(jsonString);
+          await writable.close();
+          return {
+            success: true,
+            document,
+            message: `Saved node graph directly to local folder "${customDirectoryHandle.name || "Vault"}"`,
+            targetPath: `${customDirectoryHandle.name}/${fileName}`
+          };
+        }
+      } catch (err) {
+        console.warn("Native FS Handle save warning:", err);
+      }
+    }
+    const targetPath = document.storageMetadata?.targetPath || `graphs/${document.appId}.graph.json`;
+    const targetName = document.storageMetadata?.targetName || "Vault";
+    const simulatedLatency = provider === "local_fs" ? 10 : 80;
+    await new Promise((resolve) => setTimeout(resolve, simulatedLatency));
+    return {
+      success: true,
+      document,
+      message: `Node graph saved to ${(provider || "storage").toUpperCase().replace("_", " ")} (${targetName}: ${targetPath})`,
+      targetPath
+    };
+  }
+  /**
+   * Loads a cached or previously saved node graph document for an app.
+   */
+  loadSavedGraph(appId) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        const stored = window.localStorage.getItem(`${LOCAL_STORAGE_GRAPHS_PREFIX}${appId}`);
+        if (stored) {
+          const parsed = JSON.parse(stored);
+          const validation = this.validateGraphDocument(parsed);
+          if (validation.valid && validation.document) {
+            return validation.document;
+          }
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Triggers a browser download of the node graph as a portable JSON file.
+   */
+  exportGraphAsJsonFile(graphDoc) {
+    exportGraphAsJsonFile(graphDoc);
+  }
+  /**
+   * Reads and parses a graph JSON file from an input file element.
+   */
+  async parseGraphJsonFile(file) {
+    return parseGraphJsonFile(file);
+  }
+};
+var nodeGraphPersistence = new NodeGraphPersistenceService();
+
+export {
+  createLocalService,
+  createRemoteService,
+  CompositeBackend,
+  EndpointGenerator,
+  createBackend,
+  createCompositeService,
+  LOCAL_STORAGE_GRAPHS_PREFIX,
+  validateGraphDocument,
+  exportGraphAsJsonFile,
+  parseGraphJsonFile,
+  NodeGraphPersistenceService,
+  nodeGraphPersistence
+};

package/packages/backend/dist/{chunk-MN54ZIKZ.js → chunk-KX3OTBQ3.js}

@@ -166,7 +166,7 @@ async function getPrimarySrklDeploymentUrl(queryDb) {
   cachedSrklUrl = { url: fallback, expiresAt: Date.now() + 10 * 60 * 1e3 };
   return fallback;
 }
-async function getSrklAccounts(userId, service, queryDb) {
+async function getSrklAccounts(userId, service2, queryDb) {
   const srklUrl = await getPrimarySrklDeploymentUrl(queryDb);
   const accounts = [];
   const seenKeys = /* @__PURE__ */ new Set();
@@ -182,7 +182,7 @@ async function getSrklAccounts(userId, service, queryDb) {
           ...p.loky?.storage_connections || []
         ];
         for (const conn of pool) {
-          if (service && !conn.provider?.toLowerCase().includes(service.toLowerCase())) continue;
+          if (service2 && !conn.provider?.toLowerCase().includes(service2.toLowerCase())) continue;
           const kId = (conn.b2KeyId || conn.keyId || conn.accessKeyId || "").trim();
           const key = kId ? `key:${kId}` : `id:${conn.id}`;
           if (!seenKeys.has(key)) {
@@ -216,7 +216,7 @@ async function getSrklAccounts(userId, service, queryDb) {
       const list = Array.isArray(data.services) ? data.services : [];
       for (const item of list) {
         const sId = String(item.serviceId || item.id || "").toLowerCase();
-        if (service && !sId.includes(service.toLowerCase())) continue;
+        if (service2 && !sId.includes(service2.toLowerCase())) continue;
         const kId = (item.credentials?.keyId || item.credentials?.b2KeyId || "").trim();
         const key = kId ? `key:${kId}` : `id:${item.id}`;
         if (!seenKeys.has(key)) {
@@ -325,6 +325,304 @@ function useSrklServices(options) {
   };
 }
 
+// src/srkl/SrklCryptoClient.ts
+var SALT_LENGTH = 16;
+var IV_LENGTH = 12;
+var TAG_LENGTH = 16;
+var HEADER_LENGTH = SALT_LENGTH + IV_LENGTH + TAG_LENGTH;
+var PBKDF2_ITERATIONS = 1e5;
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+async function decryptVaultBufferInBrowser(envelopeBuffer, secretHex) {
+  const rawBytes = envelopeBuffer instanceof Uint8Array ? envelopeBuffer : new Uint8Array(envelopeBuffer);
+  if (rawBytes.length < HEADER_LENGTH) {
+    throw new Error(`Invalid encrypted vault payload: buffer too short (${rawBytes.length} bytes)`);
+  }
+  const salt = rawBytes.slice(0, SALT_LENGTH);
+  const iv = rawBytes.slice(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+  const authTag = rawBytes.slice(SALT_LENGTH + IV_LENGTH, HEADER_LENGTH);
+  const ciphertext = rawBytes.slice(HEADER_LENGTH);
+  const ciphertextWithTag = new Uint8Array(ciphertext.length + authTag.length);
+  ciphertextWithTag.set(ciphertext, 0);
+  ciphertextWithTag.set(authTag, ciphertext.length);
+  const cryptoObj = typeof window !== "undefined" ? window.crypto : globalThis.crypto;
+  if (!cryptoObj?.subtle) {
+    throw new Error("Web Crypto API (crypto.subtle) is not available in this environment.");
+  }
+  const rawSecretBytes = new TextEncoder().encode(secretHex);
+  const baseKey = await cryptoObj.subtle.importKey(
+    "raw",
+    rawSecretBytes,
+    "PBKDF2",
+    false,
+    ["deriveKey"]
+  );
+  const aesKey = await cryptoObj.subtle.deriveKey(
+    {
+      name: "PBKDF2",
+      salt,
+      iterations: PBKDF2_ITERATIONS,
+      hash: "SHA-256"
+    },
+    baseKey,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["decrypt"]
+  );
+  const decryptedBuffer = await cryptoObj.subtle.decrypt(
+    {
+      name: "AES-GCM",
+      iv,
+      tagLength: 128
+    },
+    aesKey,
+    ciphertextWithTag
+  );
+  return new Uint8Array(decryptedBuffer);
+}
+
+// src/srkl/SrklCredentialRegistry.ts
+var SrklCredentialRegistry = class {
+  registry = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  /**
+   * Populate the in-memory registry directly from an initialized sql.js Database instance.
+   * Performs the set intersection: DB.services ∩ DEPM.supported_services.
+   */
+  populateFromSqlite(db, supportedServices) {
+    this.registry.clear();
+    const normalizedSupported = new Set(supportedServices.map((s) => s.toLowerCase().trim()));
+    try {
+      const res = db.exec("SELECT * FROM srkl_service_accounts");
+      if (!res || !res.length) return;
+      const { columns, values } = res[0];
+      for (const row of values) {
+        const item = {};
+        columns.forEach((col, idx) => {
+          item[col] = row[idx];
+        });
+        const serviceId = (item.service_id || "").toLowerCase().trim();
+        if (normalizedSupported.size > 0 && !normalizedSupported.has(serviceId)) {
+          continue;
+        }
+        let credentials = {};
+        let metadata = {};
+        try {
+          credentials = JSON.parse(item.credentials_json || "{}");
+        } catch {
+        }
+        try {
+          metadata = JSON.parse(item.metadata_json || "{}");
+        } catch {
+        }
+        const entry = {
+          id: item.id,
+          serviceId: item.service_id,
+          name: item.name,
+          credentials,
+          status: item.status,
+          lastSync: item.last_sync,
+          metadata,
+          createdAt: item.created_at,
+          updatedAt: item.updated_at
+        };
+        const existing = this.registry.get(entry.serviceId) || [];
+        existing.push(entry);
+        this.registry.set(entry.serviceId, existing);
+      }
+    } catch (err) {
+      console.warn("[SrklCredentialRegistry] Failed to query srkl_service_accounts table:", err.message);
+    }
+  }
+  /**
+   * Register a service account in volatile memory (for manual entry or synced accounts)
+   */
+  registerServiceAccount(account) {
+    const serviceId = (account.serviceId || "").toLowerCase().trim();
+    if (!serviceId) return;
+    if (!this.registry.has(serviceId)) {
+      this.registry.set(serviceId, []);
+    }
+    const existing = this.registry.get(serviceId);
+    const idx = existing.findIndex((a) => a.id === account.id);
+    if (idx >= 0) {
+      existing[idx] = account;
+    } else {
+      existing.push(account);
+    }
+  }
+  getAccountsForService(serviceId) {
+    return this.registry.get(serviceId.toLowerCase().trim()) || [];
+  }
+  getPrimaryAccount(serviceId) {
+    const list = this.getAccountsForService(serviceId);
+    return list[0] || null;
+  }
+  hasCredentials(serviceId) {
+    const list = this.getAccountsForService(serviceId);
+    return list.length > 0;
+  }
+  listAvailableServices() {
+    return Array.from(this.registry.keys());
+  }
+  toMap() {
+    const obj = {};
+    for (const [sId, accounts] of this.registry.entries()) {
+      obj[sId] = accounts;
+    }
+    return obj;
+  }
+  clear() {
+    this.registry.clear();
+  }
+};
+var globalCredentialRegistry = new SrklCredentialRegistry();
+
+// src/srkl/SrklVaultAccessClient.ts
+var SrklVaultAccessClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  registry = new SrklCredentialRegistry();
+  activeGrant = null;
+  sqlEngine = null;
+  /**
+   * Initialize sql.js engine (WASM).
+   * Consumers can pass pre-loaded initSqlJs or let this load from window or CDN.
+   */
+  async initSqlEngine(customInitSqlJs) {
+    if (this.sqlEngine) return this.sqlEngine;
+    const initFn = customInitSqlJs || typeof window !== "undefined" && window.initSqlJs;
+    if (!initFn) {
+      throw new Error(
+        'sql.js engine not found. Ensure "sql.js" is installed or <script src="sql-wasm.js"> is loaded.'
+      );
+    }
+    this.sqlEngine = await initFn({
+      locateFile: (file) => `/${file}`
+    });
+    return this.sqlEngine;
+  }
+  /**
+   * Full pipeline: Authorize → Presigned URL → Direct Download → Decrypt → SQLite Query → Registry.
+   */
+  async loadCredentials(userSessionToken, workspaceId, customInitSqlJs) {
+    await this.initSqlEngine(customInitSqlJs);
+    const baseUrl = this.options.srklApiBaseUrl.replace(/\/+$/, "");
+    let res;
+    try {
+      res = await fetch(`${baseUrl}/api/ecosystem/vault-access`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${userSessionToken}`,
+          "x-app-id": this.options.appId,
+          ...workspaceId ? { "x-workspace-id": workspaceId } : {}
+        },
+        body: JSON.stringify({
+          appId: this.options.appId,
+          workspaceId,
+          supportedServices: this.options.supportedServices
+        })
+      });
+    } catch (fetchErr) {
+      try {
+        res = await fetch("/api/ecosystem/vault-access", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${userSessionToken}`,
+            "x-app-id": this.options.appId,
+            ...workspaceId ? { "x-workspace-id": workspaceId } : {}
+          },
+          body: JSON.stringify({
+            appId: this.options.appId,
+            workspaceId,
+            supportedServices: this.options.supportedServices
+          })
+        });
+      } catch {
+        throw new Error(`[SrklVaultAccess] Connection to SRKL Engine (${baseUrl}) failed: ${fetchErr.message}`);
+      }
+    }
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(`[SrklVaultAccess] Failed to authorize vault access: ${err.error || res.statusText}`);
+    }
+    const grant = await res.json();
+    this.activeGrant = grant;
+    const bucketResponse = await fetch(grant.presignedUrl);
+    if (!bucketResponse.ok) {
+      throw new Error(
+        `[SrklVaultAccess] Direct cloud bucket download failed (${bucketResponse.status}): ${bucketResponse.statusText}`
+      );
+    }
+    const encryptedArrayBuffer = await bucketResponse.arrayBuffer();
+    const decryptedSqliteBytes = await decryptVaultBufferInBrowser(
+      encryptedArrayBuffer,
+      grant.keyMaterial.secretHex
+    );
+    const db = new this.sqlEngine.Database(decryptedSqliteBytes);
+    try {
+      this.registry.populateFromSqlite(db, this.options.supportedServices);
+    } finally {
+      db.close();
+    }
+    return this.registry;
+  }
+  getRegistry() {
+    return this.registry;
+  }
+  getActiveGrant() {
+    return this.activeGrant;
+  }
+  clear() {
+    this.registry.clear();
+    this.activeGrant = null;
+  }
+};
+
+// src/srkl/srklSyncBridge.ts
+async function syncSrklAccounts(userId, sessionToken, srklUrl) {
+  const resp = await fetch("/api/srkl/sync", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${sessionToken}`,
+      "x-user-id": userId
+    },
+    body: JSON.stringify({ srklUrl })
+  });
+  return await resp.json();
+}
+
+// src/srkl/srkl.ts
+var runtime = {
+  VaultAccessClient: SrklVaultAccessClient,
+  CredentialRegistry: SrklCredentialRegistry,
+  decryptVaultBufferInBrowser,
+  hexToBytes
+};
+var deployment = {
+  target: "universal",
+  supportedEngines: ["browser", "worker", "node"],
+  version: "1.0.0"
+};
+var service = {
+  name: "srkl",
+  description: "SRKL Ecosystem Volatile Memory Credential Vault Service",
+  runtime,
+  deployment
+};
+var srklService = service;
+
 export {
   CANONICAL_SRKL_URL,
   SrklClient,
@@ -332,5 +630,12 @@ export {
   getPrimarySrklDeploymentUrl,
   getSrklAccounts,
   srklListBackblazeBuckets,
-  useSrklServices
+  useSrklServices,
+  hexToBytes,
+  decryptVaultBufferInBrowser,
+  SrklCredentialRegistry,
+  globalCredentialRegistry,
+  SrklVaultAccessClient,
+  syncSrklAccounts,
+  srklService
 };