@tinycloud/sdk-core 2.11.0-beta.7 → 2.11.0-beta.9

package/dist/index.cjs

@@ -2200,13 +2200,12 @@ function digest(input, options2) {
 }
 var identity2 = { code: code2, name, encode: encode4, digest };
 
-// ../../node_modules/multiformats/dist/src/hashes/sha2.js
-var sha2_exports = {};
-__export(sha2_exports, {
+// ../../node_modules/multiformats/dist/src/hashes/sha2-browser.js
+var sha2_browser_exports = {};
+__export(sha2_browser_exports, {
   sha256: () => sha2562,
   sha512: () => sha512
 });
-var import_crypto = __toESM(require("crypto"), 1);
 
 // ../../node_modules/multiformats/dist/src/hashes/hasher.js
 var DEFAULT_MIN_DIGEST_LENGTH = 20;
@@ -2256,21 +2255,24 @@ function createDigest(digest4, code3, truncate) {
   return create(code3, digest4);
 }
 
-// ../../node_modules/multiformats/dist/src/hashes/sha2.js
+// ../../node_modules/multiformats/dist/src/hashes/sha2-browser.js
+function sha(name2) {
+  return async (data) => new Uint8Array(await crypto.subtle.digest(name2, data));
+}
 var sha2562 = from2({
   name: "sha2-256",
   code: 18,
-  encode: (input) => coerce(import_crypto.default.createHash("sha256").update(input).digest())
+  encode: sha("SHA-256")
 });
 var sha512 = from2({
   name: "sha2-512",
   code: 19,
-  encode: (input) => coerce(import_crypto.default.createHash("sha512").update(input).digest())
+  encode: sha("SHA-512")
 });
 
 // ../../node_modules/multiformats/dist/src/basics.js
 var bases = { ...identity_exports, ...base2_exports, ...base8_exports, ...base10_exports, ...base16_exports, ...base32_exports, ...base36_exports, ...base58_exports, ...base64_exports, ...base256emoji_exports };
-var hashes = { ...sha2_exports, ...identity_exports2 };
+var hashes = { ...sha2_browser_exports, ...identity_exports2 };
 
 // src/policy/signed-object.ts
 var import_viem3 = require("viem");
@@ -13823,17 +13825,9 @@ function equals3(a, b) {
   return true;
 }
 
-// ../../node_modules/uint8arrays/dist/src/alloc.node.js
-var import_node_buffer = require("buffer");
-
-// ../../node_modules/uint8arrays/dist/src/util/as-uint8array.node.js
-function asUint8Array(buf) {
-  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-}
-
-// ../../node_modules/uint8arrays/dist/src/alloc.node.js
+// ../../node_modules/uint8arrays/dist/src/alloc.js
 function allocUnsafe(size = 0) {
-  return asUint8Array(import_node_buffer.Buffer.allocUnsafe(size));
+  return new Uint8Array(size);
 }
 
 // ../../node_modules/uint8-varint/dist/src/index.js
@@ -14009,14 +14003,24 @@ function decode6(buf, offset = 0) {
   }
 }
 
-// ../../node_modules/uint8arrays/dist/src/concat.node.js
-var import_node_buffer2 = require("buffer");
-function concat(arrays, length2) {
-  return asUint8Array(import_node_buffer2.Buffer.concat(arrays, length2));
+// ../../node_modules/uint8arrays/dist/src/util/as-uint8array.js
+function asUint8Array(buf) {
+  return buf;
 }
 
-// ../../node_modules/uint8arrays/dist/src/from-string.node.js
-var import_node_buffer3 = require("buffer");
+// ../../node_modules/uint8arrays/dist/src/concat.js
+function concat(arrays, length2) {
+  if (length2 == null) {
+    length2 = arrays.reduce((acc, curr) => acc + curr.length, 0);
+  }
+  const output = allocUnsafe(length2);
+  let offset = 0;
+  for (const arr of arrays) {
+    output.set(arr, offset);
+    offset += arr.length;
+  }
+  return asUint8Array(output);
+}
 
 // ../../node_modules/uint8arrays/dist/src/util/bases.js
 function createCodec(name2, prefix, encode5, decode7) {
@@ -14065,28 +14069,21 @@ var BASES = {
 };
 var bases_default = BASES;
 
-// ../../node_modules/uint8arrays/dist/src/from-string.node.js
+// ../../node_modules/uint8arrays/dist/src/from-string.js
 function fromString2(string2, encoding = "utf8") {
   const base3 = bases_default[encoding];
   if (base3 == null) {
     throw new Error(`Unsupported encoding "${encoding}"`);
   }
-  if (encoding === "utf8" || encoding === "utf-8") {
-    return asUint8Array(import_node_buffer3.Buffer.from(string2, "utf-8"));
-  }
   return base3.decoder.decode(`${base3.prefix}${string2}`);
 }
 
-// ../../node_modules/uint8arrays/dist/src/to-string.node.js
-var import_node_buffer4 = require("buffer");
+// ../../node_modules/uint8arrays/dist/src/to-string.js
 function toString2(array, encoding = "utf8") {
   const base3 = bases_default[encoding];
   if (base3 == null) {
     throw new Error(`Unsupported encoding "${encoding}"`);
   }
-  if (encoding === "utf8" || encoding === "utf-8") {
-    return import_node_buffer4.Buffer.from(array.buffer, array.byteOffset, array.byteLength).toString("utf8");
-  }
   return base3.encoder.encode(array).substring(1);
 }
 
@@ -14120,8 +14117,218 @@ var UnknownProtocolError = class extends Error {
 };
 __publicField(UnknownProtocolError, "name", "UnknownProtocolError");
 
-// ../../node_modules/@chainsafe/is-ip/lib/is-ip.node.js
-var import_node_net = require("net");
+// ../../node_modules/@chainsafe/is-ip/lib/parser.js
+var Parser = class {
+  constructor() {
+    __publicField(this, "index", 0);
+    __publicField(this, "input", "");
+  }
+  new(input) {
+    this.index = 0;
+    this.input = input;
+    return this;
+  }
+  /** Run a parser, and restore the pre-parse state if it fails. */
+  readAtomically(fn) {
+    const index = this.index;
+    const result = fn();
+    if (result === void 0) {
+      this.index = index;
+    }
+    return result;
+  }
+  /** Run a parser, but fail if the entire input wasn't consumed. Doesn't run atomically. */
+  parseWith(fn) {
+    const result = fn();
+    if (this.index !== this.input.length) {
+      return void 0;
+    }
+    return result;
+  }
+  /** Peek the next character from the input */
+  peekChar() {
+    if (this.index >= this.input.length) {
+      return void 0;
+    }
+    return this.input[this.index];
+  }
+  /** Read the next character from the input */
+  readChar() {
+    if (this.index >= this.input.length) {
+      return void 0;
+    }
+    return this.input[this.index++];
+  }
+  /** Read the next character from the input if it matches the target. */
+  readGivenChar(target) {
+    return this.readAtomically(() => {
+      const char = this.readChar();
+      if (char !== target) {
+        return void 0;
+      }
+      return char;
+    });
+  }
+  /**
+   * Helper for reading separators in an indexed loop. Reads the separator
+   * character iff index > 0, then runs the parser. When used in a loop,
+   * the separator character will only be read on index > 0 (see
+   * readIPv4Addr for an example)
+   */
+  readSeparator(sep, index, inner) {
+    return this.readAtomically(() => {
+      if (index > 0) {
+        if (this.readGivenChar(sep) === void 0) {
+          return void 0;
+        }
+      }
+      return inner();
+    });
+  }
+  /**
+   * Read a number off the front of the input in the given radix, stopping
+   * at the first non-digit character or eof. Fails if the number has more
+   * digits than max_digits or if there is no number.
+   */
+  readNumber(radix, maxDigits, allowZeroPrefix, maxBytes) {
+    return this.readAtomically(() => {
+      let result = 0;
+      let digitCount = 0;
+      const leadingChar = this.peekChar();
+      if (leadingChar === void 0) {
+        return void 0;
+      }
+      const hasLeadingZero = leadingChar === "0";
+      const maxValue2 = 2 ** (8 * maxBytes) - 1;
+      while (true) {
+        const digit = this.readAtomically(() => {
+          const char = this.readChar();
+          if (char === void 0) {
+            return void 0;
+          }
+          const num = Number.parseInt(char, radix);
+          if (Number.isNaN(num)) {
+            return void 0;
+          }
+          return num;
+        });
+        if (digit === void 0) {
+          break;
+        }
+        result *= radix;
+        result += digit;
+        if (result > maxValue2) {
+          return void 0;
+        }
+        digitCount += 1;
+        if (maxDigits !== void 0) {
+          if (digitCount > maxDigits) {
+            return void 0;
+          }
+        }
+      }
+      if (digitCount === 0) {
+        return void 0;
+      } else if (!allowZeroPrefix && hasLeadingZero && digitCount > 1) {
+        return void 0;
+      } else {
+        return result;
+      }
+    });
+  }
+  /** Read an IPv4 address. */
+  readIPv4Addr() {
+    return this.readAtomically(() => {
+      const out = new Uint8Array(4);
+      for (let i = 0; i < out.length; i++) {
+        const ix = this.readSeparator(".", i, () => this.readNumber(10, 3, false, 1));
+        if (ix === void 0) {
+          return void 0;
+        }
+        out[i] = ix;
+      }
+      return out;
+    });
+  }
+  /** Read an IPv6 Address. */
+  readIPv6Addr() {
+    const readGroups = (groups) => {
+      for (let i = 0; i < groups.length / 2; i++) {
+        const ix = i * 2;
+        if (i < groups.length - 3) {
+          const ipv4 = this.readSeparator(":", i, () => this.readIPv4Addr());
+          if (ipv4 !== void 0) {
+            groups[ix] = ipv4[0];
+            groups[ix + 1] = ipv4[1];
+            groups[ix + 2] = ipv4[2];
+            groups[ix + 3] = ipv4[3];
+            return [ix + 4, true];
+          }
+        }
+        const group = this.readSeparator(":", i, () => this.readNumber(16, 4, true, 2));
+        if (group === void 0) {
+          return [ix, false];
+        }
+        groups[ix] = group >> 8;
+        groups[ix + 1] = group & 255;
+      }
+      return [groups.length, false];
+    };
+    return this.readAtomically(() => {
+      const head = new Uint8Array(16);
+      const [headSize, headIp4] = readGroups(head);
+      if (headSize === 16) {
+        return head;
+      }
+      if (headIp4) {
+        return void 0;
+      }
+      if (this.readGivenChar(":") === void 0) {
+        return void 0;
+      }
+      if (this.readGivenChar(":") === void 0) {
+        return void 0;
+      }
+      const tail = new Uint8Array(14);
+      const limit = 16 - (headSize + 2);
+      const [tailSize] = readGroups(tail.subarray(0, limit));
+      head.set(tail.subarray(0, tailSize), 16 - tailSize);
+      return head;
+    });
+  }
+  /** Read an IP Address, either IPv4 or IPv6. */
+  readIPAddr() {
+    return this.readIPv4Addr() ?? this.readIPv6Addr();
+  }
+};
+
+// ../../node_modules/@chainsafe/is-ip/lib/parse.js
+var MAX_IPV6_LENGTH = 45;
+var MAX_IPV4_LENGTH = 15;
+var parser = new Parser();
+function parseIPv4(input) {
+  if (input.length > MAX_IPV4_LENGTH) {
+    return void 0;
+  }
+  return parser.new(input).parseWith(() => parser.readIPv4Addr());
+}
+function parseIPv6(input) {
+  if (input.includes("%")) {
+    input = input.split("%")[0];
+  }
+  if (input.length > MAX_IPV6_LENGTH) {
+    return void 0;
+  }
+  return parser.new(input).parseWith(() => parser.readIPv6Addr());
+}
+
+// ../../node_modules/@chainsafe/is-ip/lib/is-ip.js
+function isIPv4(input) {
+  return Boolean(parseIPv4(input));
+}
+function isIPv6(input) {
+  return Boolean(parseIPv6(input));
+}
 
 // ../../node_modules/@multiformats/multiaddr/dist/src/constants.js
 var CODE_IP4 = 4;
@@ -14243,7 +14450,7 @@ var ip6ToBytes = function(ip) {
   const sections = ip.split(":", 8);
   let i;
   for (i = 0; i < sections.length; i++) {
-    const isv4 = (0, import_node_net.isIPv4)(sections[i]);
+    const isv4 = isIPv4(sections[i]);
     let v4Buffer;
     if (isv4) {
       v4Buffer = ip4ToBytes(sections[i]);
@@ -14410,7 +14617,7 @@ var codecs = [{
   valueToBytes: ip4ToBytes,
   bytesToValue: ip4ToString,
   validate: (value) => {
-    if (!(0, import_node_net.isIPv4)(value)) {
+    if (!isIPv4(value)) {
       throw new ValidationError(`Invalid IPv4 address "${value}"`);
     }
   }
@@ -14443,7 +14650,7 @@ var codecs = [{
   bytesToValue: ip6ToString,
   stringToValue: ip6StringToValue,
   validate: (value) => {
-    if (!(0, import_node_net.isIPv6)(value)) {
+    if (!isIPv6(value)) {
       throw new ValidationError(`Invalid IPv6 address "${value}"`);
     }
   }
@@ -15078,25 +15285,17 @@ ipRegex.v4 = (options2) => options2 && options2.exact ? v4exact : new RegExp(`${
 ipRegex.v6 = (options2) => options2 && options2.exact ? v6exact : new RegExp(`${boundry(options2)}${v6}${boundry(options2)}`, "g");
 var ip_regex_default = ipRegex;
 
-// ../../node_modules/function-timeout/index.js
-var import_node_vm = __toESM(require("vm"), 1);
-function functionTimeout(function_, { timeout } = {}) {
-  const script = new import_node_vm.default.Script("returnValue = function_()");
-  const wrappedFunction = (...arguments_) => {
-    const context = {
-      function_: () => function_(...arguments_)
-    };
-    script.runInNewContext(context, { timeout });
-    return context.returnValue;
-  };
+// ../../node_modules/function-timeout/browser.js
+function functionTimeout(function_) {
+  const wrappedFunction = (...arguments_) => function_(...arguments_);
   Object.defineProperty(wrappedFunction, "name", {
     value: `functionTimeout(${function_.name || "<anonymous>"})`,
     configurable: true
   });
   return wrappedFunction;
 }
-function isTimeoutError(error) {
-  return error?.code === "ERR_SCRIPT_EXECUTION_TIMEOUT";
+function isTimeoutError() {
+  return false;
 }
 
 // ../../node_modules/clone-regexp/node_modules/is-regexp/index.js
@@ -15899,320 +16098,4 @@ function decodeBase64Url(value) {
   }
   return Uint8Array.from(bytes2);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ACCOUNT_INDEX_SCHEMA,
-  ACCOUNT_REGISTRY_PATH,
-  ACCOUNT_REGISTRY_SPACE,
-  AccountService,
-  AutoApproveSpaceCreationHandler,
-  BOOTSTRAP_ALLOWLIST,
-  BOOTSTRAP_DEFAULT_SPACE,
-  BOOTSTRAP_ENCRYPTION_NETWORK_NAME,
-  BOOTSTRAP_ENCRYPTION_NETWORK_RESOURCE_TEMPLATE,
-  BOOTSTRAP_MANIFEST,
-  BOOTSTRAP_PERSISTED_APPLICATION_MANIFESTS,
-  BOOTSTRAP_PUBLIC_SPACE,
-  BOOTSTRAP_SESSION_REQUESTS,
-  BOOTSTRAP_SPACE_MANIFESTS,
-  BOOTSTRAP_SPACE_NAMES,
-  CAPABILITIES,
-  CAPABILITY_REGISTRY,
-  CapabilityKeyRegistry,
-  CapabilityKeyRegistryErrorCodes,
-  CaveatedDelegationUnsupportedError,
-  ClientSessionSchema,
-  CloudLocationResolutionError,
-  DECRYPT_ACTION,
-  DECRYPT_FACT_TYPE,
-  DECRYPT_RESULT_TYPE,
-  DEFAULT_DEFAULTS,
-  DEFAULT_ENCRYPTION_ALG,
-  DEFAULT_EXPIRY,
-  DEFAULT_KEY_VERSION,
-  DEFAULT_KNOWLEDGE_ROOT,
-  DEFAULT_LOCAL_NODE_PIN_STORAGE_KEY,
-  DEFAULT_LOCAL_NODE_URL,
-  DEFAULT_MANIFEST_SPACE,
-  DEFAULT_MANIFEST_VERSION,
-  DEFAULT_SIGNED_READ_URL_EXPIRY_MS,
-  DEFAULT_TINYCLOUD_FALLBACK_HOST,
-  DEFAULT_TINYCLOUD_LOCATION_REGISTRY_URL,
-  DUCKDB,
-  DataVaultService,
-  DatabaseHandle,
-  DecryptTransportResponseError,
-  DelegationErrorCodes,
-  DelegationManager,
-  DuckDbAction,
-  DuckDbDatabaseHandle,
-  DuckDbService,
-  ED25519_JCS_SIGNATURE_SUITE,
-  EIP191_JCS_SIGNATURE_SUITE,
-  ENCRYPTION,
-  ENCRYPTION_MANIFEST_SPACE,
-  ENCRYPTION_NETWORK_URN_PREFIX,
-  ENCRYPTION_PERMISSION_SERVICE,
-  ENCRYPTION_SERVICE,
-  ENCRYPTION_SERVICE_SHORT,
-  ENVELOPE_VERSION,
-  EXPIRY,
-  EncryptionService,
-  EnsDataSchema,
-  ErrorCodes,
-  HOLDER_KEY_BINDING_PRESENTATION_SCHEMA,
-  HOOKS,
-  HooksService,
-  IdentityParseError,
-  KV,
-  KVService,
-  LISTEN_SQL_STATEMENT_CATALOG,
-  LOCAL_LINK_HOST_SUFFIX,
-  LOCAL_LINK_PROBE_TIMEOUT_MS,
-  LOCAL_LOOPBACK_PROBE_TIMEOUT_MS,
-  LocationRecordValidationError,
-  MAX_CONTENT_BYTES,
-  MAX_SEALED_SHARE_CONTENT_BYTES,
-  MAX_SHARE_ARTIFACT_BYTES,
-  MAX_SHARE_CONTENT_BYTES,
-  ManifestValidationError,
-  MemorySenderShareKeyStorage,
-  MemorySenderShareRecordStorage,
-  MemoryShareCache,
-  NETWORK_NAME_PATTERN,
-  NetworkIdError,
-  POLICY_ENGINE_CHALLENGE_REQUEST_SCHEMA,
-  POLICY_ENGINE_CHALLENGE_RESPONSE_SCHEMA,
-  POLICY_ENGINE_DENIAL_SCHEMA,
-  POLICY_ENGINE_GRANT_PRESENTATION_DENIAL_CODES,
-  POLICY_ENGINE_RECORD_SCHEMA,
-  POLICY_ENGINE_RESOLVE_REQUEST_SCHEMA,
-  POLICY_SCHEMA,
-  POLICY_STATUS_SCHEMA,
-  PORTABLE_DELEGATION_SCHEMA,
-  PermissionNotInManifestError,
-  PrefixedKVService,
-  ProtocolMismatchError,
-  REQUESTER_ENGINE_RETRY_ATTEMPTS,
-  REQUESTER_ENGINE_RETRY_MAX_DELAY_MS,
-  REQUESTER_NEAR_EXPIRY_SECONDS,
-  SECRETS_SPACE,
-  SECRET_NAME_RE,
-  SECRET_RECORDS_SCHEMA,
-  SERVICE_LONG_TO_SHORT,
-  SERVICE_SHORT_TO_LONG,
-  SHARE_DELIVERY_AUTHORIZATION_DOMAIN,
-  SPACE,
-  SQL,
-  SQLAction,
-  SQLService,
-  SecretsService,
-  SenderShareStore,
-  ServiceContext,
-  SessionExpiredError,
-  ShareAccessError,
-  ShareAddressedDelegationEnvelopeV2Schema,
-  ShareAddressedDelegationRequestV2Schema,
-  ShareAddressedDelegationResponseV2Schema,
-  ShareConflict,
-  ShareEnvelopeError,
-  ShareNativeResponseSchema,
-  ShareRecipientClient,
-  SharingService,
-  SignatureMaterialError,
-  SignatureVerificationError,
-  SignedObjectCanonicalizationError,
-  SignedObjectDigestError,
-  SignedObjectIdError,
-  SignedObjectProfileError,
-  SignedObjectSchemaError,
-  SigningKeyBindingError,
-  SilentNotificationHandler,
-  SiweConfigSchema,
-  SiweMessage,
-  Space,
-  SpaceErrorCodes,
-  SpaceService,
-  TINYCLOUD_ACCOUNT_SPACE_MANIFEST,
-  TINYCLOUD_APPLICATIONS_SPACE_MANIFEST,
-  TINYCLOUD_DEFAULT_SPACE_MANIFEST,
-  TINYCLOUD_PUBLIC_SPACE_MANIFEST,
-  TINYCLOUD_SECRETS_BOOTSTRAP_MANIFEST,
-  TinyCloud,
-  TinyCloudDebugLogger,
-  TranscriptRequester,
-  TranscriptRequesterError,
-  UnsupportedFeatureError,
-  UnsupportedSignatureSuiteError,
-  VAULT_PERMISSION_SERVICE,
-  VaultHeaders,
-  VaultPublicSpaceKVActions,
-  VersionCheckError,
-  actionContains,
-  activateSessionWithHost,
-  addressStorageKey,
-  applyPrefix,
-  bootstrapEncryptionNetworkId,
-  bootstrapSpaceId,
-  bootstrapSteps,
-  buildCanonicalDecryptRequest,
-  buildDecryptAttenuation,
-  buildDecryptFacts,
-  buildDecryptInvocation,
-  buildNetworkId,
-  buildSpaceUri,
-  canonicalHashHex,
-  canonicalLocationPayload,
-  canonicalOwnerSharePolicy,
-  canonicalSignedResponse,
-  canonicalizeAddress,
-  canonicalizeDid,
-  canonicalizeDidUrl,
-  canonicalizeEncryptionJson,
-  canonicalizeNetworkId,
-  canonicalizeRecapCaveats,
-  canonicalizeSecretScope,
-  canonicalizeSignedObjectUnsigned,
-  checkDecryptInvocationInput,
-  checkNodeInfo,
-  clearTinyCloudDebugLogs,
-  composeBootstrapSpaceManifest,
-  composeManifestRequest,
-  computeOwnerShareRegistrationCid,
-  computeShareCid,
-  createAndSignPolicy,
-  createAndSignPolicyEngineRecord,
-  createAndSignPolicyStatus,
-  createAndSignSignedObject,
-  createCapabilityKeyRegistry,
-  createDelegatedShareKey,
-  createInMemoryLocalNodeIdentityStore,
-  createLocalStorageLocalNodeIdentityStore,
-  createOpenKeyCallbackSigningStrategy,
-  createPolicyEnforcementDelegation,
-  createShareArtifact,
-  createShareArtifactAsync,
-  createSharePolicy,
-  createSharingService,
-  createSpaceService,
-  createTranscriptRequester,
-  createVaultCrypto,
-  decryptEnvelopeWithKey,
-  decryptShareBytesAsync,
-  defaultRetryPolicy,
-  defaultSignStrategy,
-  defaultSpaceCreationHandler,
-  deriveDelegationCid,
-  deriveSignedObjectMaterial,
-  deriveSignedReceiverKey,
-  didCacheKey,
-  didEquals,
-  disableTinyCloudDebug,
-  discoverLocalTinyCloudNode,
-  discoverNetwork,
-  enableTinyCloudDebug,
-  encodeInlineShareUrl,
-  encodeShareArtifact,
-  encodeShareUrl,
-  encryptShareBytes,
-  encryptShareBytesAsync,
-  encryptToNetwork,
-  encryptionBase64Decode,
-  encryptionBase64Encode,
-  encryptionError,
-  encryptionUtf8Decode,
-  encryptionUtf8Encode,
-  ensureNetworkUsableForDecrypt,
-  err,
-  expandActionShortNames,
-  expandPermissionEntries,
-  expandPermissionEntry,
-  fetchLocationRecord,
-  fetchPeerId,
-  generateRandomReceiverKey,
-  getTinyCloudDebugLogs,
-  hexDecode,
-  hexEncode,
-  httpUrlToMultiaddr,
-  installTinyCloudDebugGlobals,
-  intersectShareCapabilities,
-  isCapabilitySubset,
-  isEvmAddress,
-  isNetworkId,
-  isV2ShareLink,
-  jcsCanonicalize,
-  loadManifest,
-  locationPayloadForRecord,
-  makePkhSpaceId,
-  makePublicSpaceId,
-  manifestAbilitiesUnion,
-  multiaddrToHttpUrl,
-  networkDiscoveryKey,
-  normalizeDefaults,
-  normalizeJson,
-  normalizeShareActions,
-  normalizeShareRecipientTarget,
-  normalizeShareResource,
-  ok,
-  openWrappedKey,
-  parseCanonicalNetworkId,
-  parseExpiry,
-  parseNetworkId,
-  parseNodeNativePortableDelegation,
-  parsePkhDid,
-  parseRecapCapabilities,
-  parseShareArtifact,
-  parseShareUrl,
-  parseSpaceUri,
-  pkhDid,
-  principalDid,
-  principalDidEquals,
-  recapCaveatsEqual,
-  resolveCloudLocation,
-  resolveManifest,
-  resolveManifestKnowledgeRoot,
-  resolveSecretListPrefix,
-  resolveSecretPath,
-  resolveTinyCloudHosts,
-  resourceCapabilitiesToAbilitiesMap,
-  resourceCapabilitiesToSpaceAbilitiesMap,
-  restoreDelegatedShareKey,
-  serializeJcsJson,
-  serviceError,
-  shareCapabilityAllows,
-  shareDeliveryTrustedKid,
-  signLocationRecord,
-  signShareEnvelope,
-  signedObjectIdFor,
-  submitHostDelegation,
-  tinyCloudDebugLogger,
-  toSignedObjectError,
-  validateClientSession,
-  validateEnvelope,
-  validateLocationRecord,
-  validateLocationRecordPayload,
-  validateManifest,
-  validateOwnerSharePolicyRegistration,
-  validateOwnerSharePolicyRegistrationBytes,
-  validatePersistedSessionData,
-  validatePolicyEngineRecordSigned,
-  validatePolicyEngineRecordSignedShape,
-  validatePolicyEngineRecordUnsigned,
-  validatePolicySigned,
-  validatePolicySignedShape,
-  validatePolicyStatusSigned,
-  validatePolicyStatusSignedShape,
-  validatePolicyStatusUnsigned,
-  validatePolicyUnsigned,
-  validateShareDeliveryAuthorizationBytes,
-  verifyDecryptResponse,
-  verifyDidKeyEd25519Signature,
-  verifyLocationRecord,
-  verifyPolicy,
-  verifyPolicyEngineRecord,
-  verifyPolicyStatus,
-  verifyShareCid,
-  verifyShareEnvelope,
-  verifySignedObject
-});
 //# sourceMappingURL=index.cjs.map