@powerhousedao/connect 1.0.16-dev.2 → 1.0.16-staging.0

package/dist/assets/index-CpmCEBJz.js

@@ -0,0 +1,404 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _DB_NAME, _STORE_NAME, _KEY, _db, _BrowserKeyStorage_instances, useStore_fn, _subtleCrypto, _keyPair, _keyPairStorage, _did, _ConnectCrypto_instances, initCrypto_fn, initialize_fn, parseDid_fn, generateECDSAKeyPair_fn, exportKeyPair_fn, importKeyPair_fn, _sign, _verify, _store, _namespace, _BaseStorage_instances, buildKey_fn, _baseUrl, _store2, _connectId, _eventEmitter, _Renown_instances, updateUser_fn, getCredential_fn;
+import { _ as __vitePreload } from "./main.BuoJ8woF.js";
+import { r as rawKeyInHexfromUncompressed, c as compressedKeyInHexfromRaw, e as encodeDIDfromHexString, a as eventsExports, R as RENOWN_URL, g as getEnsInfo } from "./app-BjxLqcmz.js";
+import { i, h, d, j, b, f, s } from "./app-BjxLqcmz.js";
+import { ah as connectConfig, ac as logger } from "./app-loader-nik9-lTL.js";
+import "react/jsx-runtime";
+import "react";
+import "react-dom";
+const _BrowserKeyStorage = class _BrowserKeyStorage {
+  constructor() {
+    __privateAdd(this, _BrowserKeyStorage_instances);
+    __privateAdd(this, _db);
+    __privateSet(this, _db, new Promise((resolve, reject) => {
+      const req = indexedDB.open(__privateGet(_BrowserKeyStorage, _DB_NAME), 1);
+      req.onupgradeneeded = () => {
+        req.result.createObjectStore(__privateGet(_BrowserKeyStorage, _STORE_NAME));
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    }));
+  }
+  async saveKeyPair(keyPair) {
+    const store2 = await __privateMethod(this, _BrowserKeyStorage_instances, useStore_fn).call(this);
+    const request = store2.put(keyPair, __privateGet(_BrowserKeyStorage, _KEY));
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        resolve();
+      };
+      request.onerror = () => {
+        reject(new Error("Failed to save key pair"));
+      };
+    });
+  }
+  async loadKeyPair() {
+    const store2 = await __privateMethod(this, _BrowserKeyStorage_instances, useStore_fn).call(this, "readonly");
+    const request = store2.getAll();
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        const keyPair = request.result.length ? request.result[0] : void 0;
+        resolve(keyPair);
+      };
+      request.onerror = () => {
+        reject(new Error("Failed to load key pair"));
+      };
+    });
+  }
+};
+_DB_NAME = new WeakMap();
+_STORE_NAME = new WeakMap();
+_KEY = new WeakMap();
+_db = new WeakMap();
+_BrowserKeyStorage_instances = new WeakSet();
+useStore_fn = async function(mode = "readwrite") {
+  const database = await __privateGet(this, _db);
+  const transaction = database.transaction(
+    __privateGet(_BrowserKeyStorage, _STORE_NAME),
+    mode
+  );
+  const store2 = transaction.objectStore(__privateGet(_BrowserKeyStorage, _STORE_NAME));
+  return store2;
+};
+__privateAdd(_BrowserKeyStorage, _DB_NAME, "browserKeyDB");
+__privateAdd(_BrowserKeyStorage, _STORE_NAME, "keyPairs");
+__privateAdd(_BrowserKeyStorage, _KEY, "keyPair");
+let BrowserKeyStorage = _BrowserKeyStorage;
+function ab2hex(ab) {
+  return Array.prototype.map.call(
+    new Uint8Array(ab),
+    (x) => ("00" + x.toString(16)).slice(-2)
+  ).join("");
+}
+const _ConnectCrypto = class _ConnectCrypto {
+  constructor(keyPairStorage) {
+    __privateAdd(this, _ConnectCrypto_instances);
+    __privateAdd(this, _subtleCrypto);
+    __privateAdd(this, _keyPair);
+    __privateAdd(this, _keyPairStorage);
+    __privateAdd(this, _did);
+    __privateAdd(this, _sign, async (...args) => {
+      return (await __privateGet(this, _subtleCrypto)).sign(...args);
+    });
+    __privateAdd(this, _verify, async (...args) => {
+      return (await __privateGet(this, _subtleCrypto)).verify(...args);
+    });
+    __privateSet(this, _keyPairStorage, keyPairStorage);
+    __privateSet(this, _subtleCrypto, __privateMethod(this, _ConnectCrypto_instances, initCrypto_fn).call(this));
+    __privateSet(this, _did, __privateMethod(this, _ConnectCrypto_instances, initialize_fn).call(this));
+  }
+  did() {
+    return __privateGet(this, _did);
+  }
+  async regenerateDid() {
+    __privateSet(this, _keyPair, await __privateMethod(this, _ConnectCrypto_instances, generateECDSAKeyPair_fn).call(this));
+    await __privateGet(this, _keyPairStorage).saveKeyPair(await __privateMethod(this, _ConnectCrypto_instances, exportKeyPair_fn).call(this));
+  }
+  async sign(data) {
+    var _a;
+    if ((_a = __privateGet(this, _keyPair)) == null ? void 0 : _a.privateKey) {
+      const subtleCrypto = await __privateGet(this, _subtleCrypto);
+      const arrayBuffer = await subtleCrypto.sign(
+        _ConnectCrypto.signAlgorithm,
+        __privateGet(this, _keyPair).privateKey,
+        data.buffer
+      );
+      return new Uint8Array(arrayBuffer);
+    } else {
+      throw new Error("No private key available");
+    }
+  }
+};
+_subtleCrypto = new WeakMap();
+_keyPair = new WeakMap();
+_keyPairStorage = new WeakMap();
+_did = new WeakMap();
+_ConnectCrypto_instances = new WeakSet();
+initCrypto_fn = function() {
+  return new Promise((resolve, reject) => {
+    var _a;
+    if (typeof window === "undefined") {
+      __vitePreload(() => import("node:crypto"), true ? [] : void 0).then((module) => {
+        resolve(module.webcrypto.subtle);
+      }).catch(reject);
+    } else {
+      if (!((_a = window.crypto) == null ? void 0 : _a.subtle)) {
+        reject(new Error("Crypto module not available"));
+      }
+      resolve(window.crypto.subtle);
+    }
+  });
+};
+initialize_fn = async function() {
+  const loadedKeyPair = await __privateGet(this, _keyPairStorage).loadKeyPair();
+  if (loadedKeyPair) {
+    __privateSet(this, _keyPair, await __privateMethod(this, _ConnectCrypto_instances, importKeyPair_fn).call(this, loadedKeyPair));
+    console.log("Found key pair");
+  } else {
+    __privateSet(this, _keyPair, await __privateMethod(this, _ConnectCrypto_instances, generateECDSAKeyPair_fn).call(this));
+    console.log("Created key pair");
+    await __privateGet(this, _keyPairStorage).saveKeyPair(await __privateMethod(this, _ConnectCrypto_instances, exportKeyPair_fn).call(this));
+  }
+  const did = await __privateMethod(this, _ConnectCrypto_instances, parseDid_fn).call(this);
+  console.log("Connect DID:", did);
+  return did;
+};
+parseDid_fn = async function() {
+  if (!__privateGet(this, _keyPair)) {
+    throw new Error("No key pair available");
+  }
+  const subtleCrypto = await __privateGet(this, _subtleCrypto);
+  const publicKeyRaw = await subtleCrypto.exportKey(
+    "raw",
+    __privateGet(this, _keyPair).publicKey
+  );
+  const multicodecName = "p256-pub";
+  const rawKey = rawKeyInHexfromUncompressed(ab2hex(publicKeyRaw));
+  const compressedKey = compressedKeyInHexfromRaw(rawKey);
+  const did = encodeDIDfromHexString(multicodecName, compressedKey);
+  return did;
+};
+generateECDSAKeyPair_fn = async function() {
+  const subtleCrypto = await __privateGet(this, _subtleCrypto);
+  const keyPair = await subtleCrypto.generateKey(
+    _ConnectCrypto.algorithm,
+    true,
+    ["sign", "verify"]
+  );
+  return keyPair;
+};
+exportKeyPair_fn = async function() {
+  if (!__privateGet(this, _keyPair)) {
+    throw new Error("No key pair available");
+  }
+  const subtleCrypto = await __privateGet(this, _subtleCrypto);
+  const jwkKeyPair = {
+    publicKey: await subtleCrypto.exportKey(
+      "jwk",
+      __privateGet(this, _keyPair).publicKey
+    ),
+    privateKey: await subtleCrypto.exportKey(
+      "jwk",
+      __privateGet(this, _keyPair).privateKey
+    )
+  };
+  return jwkKeyPair;
+};
+importKeyPair_fn = async function(jwkKeyPair) {
+  const subtleCrypto = await __privateGet(this, _subtleCrypto);
+  return {
+    publicKey: await subtleCrypto.importKey(
+      "jwk",
+      jwkKeyPair.publicKey,
+      _ConnectCrypto.algorithm,
+      true,
+      ["verify"]
+    ),
+    privateKey: await subtleCrypto.importKey(
+      "jwk",
+      jwkKeyPair.privateKey,
+      _ConnectCrypto.algorithm,
+      true,
+      ["sign"]
+    )
+  };
+};
+_sign = new WeakMap();
+_verify = new WeakMap();
+__publicField(_ConnectCrypto, "algorithm", {
+  name: "ECDSA",
+  namedCurve: "P-256"
+});
+__publicField(_ConnectCrypto, "signAlgorithm", {
+  name: "ECDSA",
+  namedCurve: "P-256",
+  hash: "SHA-256"
+});
+let ConnectCrypto = _ConnectCrypto;
+function parsePkhDid(did) {
+  const parts = did.split(":");
+  if (!did.startsWith("did:pkh:") || parts.length !== 5) {
+    throw new Error("Invalid pkh did");
+  }
+  const [, , networkId, chainIdStr, address] = parts;
+  if (!address.startsWith("0x")) {
+    throw new Error(`Invalid address: ${address}`);
+  }
+  const chainId = Number(chainIdStr);
+  if (isNaN(chainId)) {
+    throw new Error(`Invalid chain id: ${chainIdStr}`);
+  }
+  return {
+    chainId,
+    networkId,
+    address
+  };
+}
+class BaseStorage {
+  constructor(store2, namespace) {
+    __privateAdd(this, _BaseStorage_instances);
+    __privateAdd(this, _store);
+    __privateAdd(this, _namespace);
+    __privateSet(this, _store, store2);
+    __privateSet(this, _namespace, namespace);
+  }
+  get(key) {
+    return __privateGet(this, _store).get(__privateMethod(this, _BaseStorage_instances, buildKey_fn).call(this, key));
+  }
+  set(key, value) {
+    return __privateGet(this, _store).set(__privateMethod(this, _BaseStorage_instances, buildKey_fn).call(this, key), value);
+  }
+  delete(key) {
+    return __privateGet(this, _store).delete(__privateMethod(this, _BaseStorage_instances, buildKey_fn).call(this, key));
+  }
+}
+_store = new WeakMap();
+_namespace = new WeakMap();
+_BaseStorage_instances = new WeakSet();
+buildKey_fn = function(key) {
+  return `${__privateGet(this, _namespace)}:${key.toString()}`;
+};
+const store = {
+  get: function(key) {
+    const value = localStorage.getItem(key);
+    if (value) {
+      return JSON.parse(value);
+    }
+    return void 0;
+  },
+  set: function(key, value) {
+    return value ? localStorage.setItem(key, JSON.stringify(value)) : localStorage.removeItem(key);
+  },
+  delete: function(key) {
+    return localStorage.removeItem(key);
+  }
+};
+class BrowserStorage extends BaseStorage {
+  constructor(namespace) {
+    super(
+      store,
+      `${connectConfig.routerBasename}:${namespace}`
+    );
+  }
+}
+function initRenownBrowser(connectId) {
+  return new Renown(new BrowserStorage("renown"), connectId);
+}
+class Renown {
+  constructor(store2, connectId, baseUrl = RENOWN_URL) {
+    __privateAdd(this, _Renown_instances);
+    __privateAdd(this, _baseUrl);
+    __privateAdd(this, _store2);
+    __privateAdd(this, _connectId);
+    __privateAdd(this, _eventEmitter, new eventsExports.EventEmitter());
+    __privateSet(this, _store2, store2);
+    __privateSet(this, _connectId, connectId);
+    __privateSet(this, _baseUrl, baseUrl);
+    if (this.user) {
+      this.login(this.user.did).catch(() => void 0);
+    }
+  }
+  get user() {
+    return __privateGet(this, _store2).get("user");
+  }
+  set connectId(connectId) {
+    __privateSet(this, _connectId, connectId);
+    const user = this.user;
+    __privateMethod(this, _Renown_instances, updateUser_fn).call(this, void 0);
+    if (user) {
+      this.login(user.did).catch((e) => {
+        console.log("User no longer authenticated:", e);
+      });
+    }
+  }
+  async login(did) {
+    try {
+      const result = parsePkhDid(did);
+      const credential = await __privateMethod(this, _Renown_instances, getCredential_fn).call(this, result.address, result.chainId, __privateGet(this, _connectId));
+      if (!credential) {
+        __privateMethod(this, _Renown_instances, updateUser_fn).call(this, void 0);
+        throw new Error("Credential not found");
+      }
+      const user = {
+        ...result,
+        did,
+        credential
+      };
+      getEnsInfo(user.address, user.chainId).then((ens) => {
+        var _a;
+        if (((_a = this.user) == null ? void 0 : _a.address) === user.address && this.user.chainId === user.chainId) {
+          __privateMethod(this, _Renown_instances, updateUser_fn).call(this, { ...this.user, ens });
+        }
+      }).catch(logger.error);
+      __privateMethod(this, _Renown_instances, updateUser_fn).call(this, user);
+      return user;
+    } catch (error) {
+      logger.error(error);
+      __privateMethod(this, _Renown_instances, updateUser_fn).call(this, void 0);
+      throw error;
+    }
+  }
+  logout() {
+    __privateMethod(this, _Renown_instances, updateUser_fn).call(this, void 0);
+  }
+  on(event, listener) {
+    __privateGet(this, _eventEmitter).on(event, listener);
+    return () => {
+      __privateGet(this, _eventEmitter).removeListener(event, listener);
+    };
+  }
+}
+_baseUrl = new WeakMap();
+_store2 = new WeakMap();
+_connectId = new WeakMap();
+_eventEmitter = new WeakMap();
+_Renown_instances = new WeakSet();
+updateUser_fn = function(user) {
+  user ? __privateGet(this, _store2).set("user", user) : __privateGet(this, _store2).delete("user");
+  __privateGet(this, _eventEmitter).emit("user", user);
+};
+getCredential_fn = async function(address, chainId, connectId) {
+  if (!__privateGet(this, _baseUrl)) {
+    throw new Error("RENOWN_URL is not set");
+  }
+  const url = new URL(
+    `/api/auth/credential?address=${encodeURIComponent(address)}&chainId=${encodeURIComponent(chainId)}&connectId=${encodeURIComponent(connectId)}`,
+    __privateGet(this, _baseUrl)
+  );
+  const response = await fetch(url, {
+    method: "GET"
+  });
+  if (response.ok) {
+    const result = await response.json();
+    return result.credential;
+  } else {
+    throw new Error("Failed to get credential");
+  }
+};
+export {
+  BaseStorage,
+  BrowserKeyStorage,
+  ConnectCrypto,
+  i as RENOWN_CHAIN_ID,
+  h as RENOWN_NETWORK_ID,
+  RENOWN_URL,
+  Renown,
+  d as addExternalPackage,
+  j as getChain,
+  getEnsInfo,
+  b as getHMRModule,
+  initRenownBrowser,
+  parsePkhDid,
+  f as removeExternalPackage,
+  s as subscribeExternalPackages
+};

package/dist/assets/{index-BuxuyYQU.js → index-DaRMlvdk.js}

@@ -1,16 +1,10 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-import { t as twMerge, a8 as clsx, a9 as get, aa as set, ab as appendErrors, ac as useFormContext, ad as Primitive, ae as cva, af as FormProvider, ag as Controller, ah as Slot, ai as useForm, aj as Root2, ak as List, al as Trigger, am as Content, an as setModelName, ao as setModelId, ap as setModelDescription, aq as setModelExtension, ar as setAuthorName, as as setAuthorWebsite, at as setStateSchema, au as setInitialState, av as addModule, aw as setModuleName, ax as deleteModule, ay as addOperation, az as setOperationName, aA as setOperationSchema, aB as setOperationDescription, aC as deleteOperation, aD as addOperationError, aE as deleteOperationError, aF as setOperationErrorName } from "./app-DhH3gUSI.js";
-import { ba as inspect$1, bb as GraphQLError$1, bc as getNamedType, bd as invariant$2, be as isInputObjectType, bf as isScalarType, bg as isObjectType, bh as isInterfaceType, bi as isUnionType, bj as isEnumType, bk as print, bl as isPrintableAsBlockString, bm as Kind, bn as astFromValue$1, bo as DEFAULT_DEPRECATION_REASON, bp as isSpecifiedDirective, bq as isSpecifiedScalarType, br as isIntrospectionType, bs as z, bt as GraphQLScalarType, Z as pascalCase, bu as parse, bv as visit, bw as buildASTSchema, bx as extendSchema, by as getNullableType, bz as isListType, $ as getDefaultExportFromCjs, bA as snakeCase, bB as constantCase, bC as isAbstractType, bD as BREAK, bE as GraphQLInputObjectType, bF as GraphQLList, bG as GraphQLEnumType, bH as GraphQLObjectType, bI as GraphQLInterfaceType, bJ as SchemaMetaFieldDef, bK as TypeMetaFieldDef, bL as TypeNameMetaFieldDef, bM as isCompositeType, bN as isOutputType, bO as isInputType, bP as GraphQLBoolean, bQ as assertAbstractType, bR as doTypesOverlap, bS as DirectiveLocation, bT as specifiedRules$1, bU as NoUnusedFragmentsRule$1, bV as ExecutableDefinitionsRule$1, bW as validate$2, bX as validateSchema, bY as GraphQLID, bZ as GraphQLString, b_ as GraphQLFloat, b$ as GraphQLInt, c0 as GraphQLDirective, c1 as GraphQLUnionType, c2 as isNonNullType, c3 as GraphQLNonNull, c4 as isNamedType, c5 as isLeafType, c6 as GraphQLSchema, c7 as buildSchema, c8 as sentenceCase, am as hashKey } from "./app-loader-Btk_wf_z.js";
+import { t as twMerge, ag as clsx, ah as get, ai as set, aj as appendErrors, ak as useFormContext, al as Primitive, am as cva, an as FormProvider, ao as Controller, ap as Slot, aq as useForm, ar as Root2, as as List, at as Trigger, au as Content, av as setModelName, aw as setModelId, ax as setModelDescription, ay as setModelExtension, az as setAuthorName, aA as setAuthorWebsite, aB as setStateSchema, aC as setInitialState, aD as addModule, aE as setModuleName, aF as deleteModule, aG as addOperation, aH as setOperationName, aI as setOperationSchema, aJ as setOperationDescription, aK as deleteOperation, aL as addOperationError, aM as deleteOperationError, aN as setOperationErrorName } from "./app-BjxLqcmz.js";
+import { bb as inspect$1, bc as GraphQLError$1, bd as getNamedType, be as invariant$2, bf as isInputObjectType, bg as isScalarType, bh as isObjectType, bi as isInterfaceType, bj as isUnionType, bk as isEnumType, bl as print, bm as isPrintableAsBlockString, bn as Kind, bo as astFromValue$1, bp as DEFAULT_DEPRECATION_REASON, bq as isSpecifiedDirective, br as isSpecifiedScalarType, bs as isIntrospectionType, bt as z, bu as GraphQLScalarType, Z as pascalCase, bv as parse, bw as visit, bx as buildASTSchema, by as extendSchema, bz as getNullableType, bA as isListType, $ as getDefaultExportFromCjs, bB as snakeCase, bC as constantCase, bD as isAbstractType, bE as BREAK, bF as GraphQLInputObjectType, bG as GraphQLList, bH as GraphQLEnumType, bI as GraphQLObjectType, bJ as GraphQLInterfaceType, bK as SchemaMetaFieldDef, bL as TypeMetaFieldDef, bM as TypeNameMetaFieldDef, bN as isCompositeType, bO as isOutputType, bP as isInputType, bQ as GraphQLBoolean, bR as assertAbstractType, bS as doTypesOverlap, bT as DirectiveLocation, bU as specifiedRules$1, bV as NoUnusedFragmentsRule$1, bW as ExecutableDefinitionsRule$1, bX as validate$2, bY as validateSchema, bZ as GraphQLID, b_ as GraphQLString, b$ as GraphQLFloat, c0 as GraphQLInt, c1 as GraphQLDirective, c2 as GraphQLUnionType, c3 as isNonNullType, c4 as GraphQLNonNull, c5 as isNamedType, c6 as isLeafType, c7 as GraphQLSchema, c8 as buildSchema, c9 as sentenceCase, an as hashKey } from "./app-loader-nik9-lTL.js";
 import * as React from "react";
 import React__default, { forwardRef, useRef, useCallback, useImperativeHandle, useEffect, useState, createContext, useContext, memo, useId, useMemo } from "react";
-import "./main.C1DJvpcL.js";
-import "@powerhousedao/reactor-browser";
+import "./main.BuoJ8woF.js";
 import "react-dom";
-import "@powerhousedao/reactor-browser/hooks/useUiNodesContext";
-import "@powerhousedao/reactor-browser/hooks/useDriveActionsWithUiNodes";
-import "@powerhousedao/reactor-browser/hooks/useDriveContext";
-import "@powerhousedao/reactor-browser/uiNodes/constants";
-import "@powerhousedao/reactor-browser/hooks/document-state";
 const versionInfo = Object.freeze({
   major: 16,
   minor: 10,

package/dist/assets/{main.C1DJvpcL.js → main.BuoJ8woF.js}

@@ -99,7 +99,7 @@ const __vitePreload = function preload(baseModule, deps, importerUrl) {
     return baseModule().catch(handlePreloadError);
   });
 };
-__vitePreload(() => import("./index-Whh7mT2J.js"), true ? [] : void 0);
+__vitePreload(() => import("./index-11j-ZVsN.js"), true ? [] : void 0);
 export {
   __vitePreload as _
 };

package/dist/index.html

@@ -64,4 +64,4 @@
     "react-dom": "https://esm.sh/react-dom",
     "react-dom/": "https://esm.sh/react-dom/"
   }
-}</script><script type="module" crossorigin="" src="/assets/main.C1DJvpcL.js"></script></head><body><div id="app"></div></body></html>
+}</script><script type="module" crossorigin="" src="/assets/main.BuoJ8woF.js"></script></head><body><div id="app"></div></body></html>

package/dist/vite-envs.sh

@@ -11,7 +11,7 @@ replaceAll() {
     }'
 }
 
-html=$(echo "PCFET0NUWVBFIGh0bWw+PGh0bWw+PGhlYWQ+PG1ldGEgY2hhcnNldD0iVVRGLTgiPjxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD1kZXZpY2Utd2lkdGgsaW5pdGlhbC1zY2FsZT0xIj48dGl0bGU+UG93ZXJob3VzZSBDb25uZWN0PC90aXRsZT48YmFzZSBocmVmPSIvIj48bGluayByZWw9Imljb24iIGhyZWY9Ii9pY29uLmljbyI+PCEtLSB2aXRlLWVudnMgc2NyaXB0IHBsYWNlaG9sZGVyIHhLc1BtTHMzMHN3S3NkSXNWeCAtLT48c2NyaXB0IHR5cGU9ImltcG9ydG1hcCI+ewogICJpbXBvcnRzIjogewogICAgInJlYWN0IjogImh0dHBzOi8vZXNtLnNoL3JlYWN0IiwKICAgICJyZWFjdC8iOiAiaHR0cHM6Ly9lc20uc2gvcmVhY3QvIiwKICAgICJyZWFjdC1kb20iOiAiaHR0cHM6Ly9lc20uc2gvcmVhY3QtZG9tIiwKICAgICJyZWFjdC1kb20vIjogImh0dHBzOi8vZXNtLnNoL3JlYWN0LWRvbS8iCiAgfQp9PC9zY3JpcHQ+PHNjcmlwdCB0eXBlPSJtb2R1bGUiIGNyb3Nzb3JpZ2luPSIiIHNyYz0iL2Fzc2V0cy9tYWluLkMxREp2cGNMLmpzIj48L3NjcmlwdD48L2hlYWQ+PGJvZHk+PGRpdiBpZD0iYXBwIj48L2Rpdj48L2JvZHk+PC9odG1sPg==" | base64 -d)
+html=$(echo "PCFET0NUWVBFIGh0bWw+PGh0bWw+PGhlYWQ+PG1ldGEgY2hhcnNldD0iVVRGLTgiPjxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD1kZXZpY2Utd2lkdGgsaW5pdGlhbC1zY2FsZT0xIj48dGl0bGU+UG93ZXJob3VzZSBDb25uZWN0PC90aXRsZT48YmFzZSBocmVmPSIvIj48bGluayByZWw9Imljb24iIGhyZWY9Ii9pY29uLmljbyI+PCEtLSB2aXRlLWVudnMgc2NyaXB0IHBsYWNlaG9sZGVyIHhLc1BtTHMzMHN3S3NkSXNWeCAtLT48c2NyaXB0IHR5cGU9ImltcG9ydG1hcCI+ewogICJpbXBvcnRzIjogewogICAgInJlYWN0IjogImh0dHBzOi8vZXNtLnNoL3JlYWN0IiwKICAgICJyZWFjdC8iOiAiaHR0cHM6Ly9lc20uc2gvcmVhY3QvIiwKICAgICJyZWFjdC1kb20iOiAiaHR0cHM6Ly9lc20uc2gvcmVhY3QtZG9tIiwKICAgICJyZWFjdC1kb20vIjogImh0dHBzOi8vZXNtLnNoL3JlYWN0LWRvbS8iCiAgfQp9PC9zY3JpcHQ+PHNjcmlwdCB0eXBlPSJtb2R1bGUiIGNyb3Nzb3JpZ2luPSIiIHNyYz0iL2Fzc2V0cy9tYWluLkJ1b0o4d29GLmpzIj48L3NjcmlwdD48L2hlYWQ+PGJvZHk+PGRpdiBpZD0iYXBwIj48L2Rpdj48L2JvZHk+PC9odG1sPg==" | base64 -d)
 
 BASE_URL_base64="eEFwV2RSclg5OWtQclZnZ0UiLyIK"
 BASE_URL=$(echo "Lwo=" | base64 -d)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@powerhousedao/connect",
   "productName": "Powerhouse-Connect",
-  "version": "1.0.16-dev.2",
+  "version": "1.0.16-staging.0",
   "description": "Powerhouse Connect",
   "main": "./dist/index.html",
   "type": "module",
@@ -82,14 +82,14 @@
     "vite-plugin-svgr": "^4.2.0",
     "vite-tsconfig-paths": "^4.3.2",
     "xvfb-maybe": "^0.2.1",
-    "@powerhousedao/builder-tools": "0.9.27-dev.2",
-    "@powerhousedao/config": "1.27.0-dev.5",
-    "@powerhousedao/reactor-browser": "1.22.25-dev.0",
-    "@powerhousedao/scalars": "1.33.1-dev.4",
-    "@powerhousedao/common": "1.10.30-dev.0",
-    "@powerhousedao/design-system": "1.39.17-dev.0",
-    "document-drive": "1.29.9-dev.2",
-    "document-model": "2.28.1-dev.4"
+    "@powerhousedao/builder-tools": "0.9.27-staging.0",
+    "@powerhousedao/config": "1.27.0-staging.2",
+    "@powerhousedao/design-system": "1.39.17-staging.0",
+    "@powerhousedao/common": "1.10.31-staging.0",
+    "@powerhousedao/reactor-browser": "1.22.25-staging.0",
+    "@powerhousedao/scalars": "1.33.1-staging.2",
+    "document-drive": "1.29.9-staging.0",
+    "document-model": "2.28.1-staging.2"
   },
   "optionalDependencies": {
     "@esbuild/linux-x64": "^0.21.4",