@tinycloud/node-sdk 2.4.0-beta.8 → 2.4.0

package/dist/core.cjs

@@ -30,95 +30,103 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/core.ts
 var core_exports = {};
 __export(core_exports, {
-  ACCOUNT_REGISTRY_PATH: () => import_sdk_core10.ACCOUNT_REGISTRY_PATH,
-  ACCOUNT_REGISTRY_SPACE: () => import_sdk_core10.ACCOUNT_REGISTRY_SPACE,
-  AccountService: () => import_sdk_core3.AccountService,
-  AutoApproveSpaceCreationHandler: () => import_sdk_core9.AutoApproveSpaceCreationHandler,
-  CapabilityKeyRegistry: () => import_sdk_core16.CapabilityKeyRegistry,
-  CapabilityKeyRegistryErrorCodes: () => import_sdk_core16.CapabilityKeyRegistryErrorCodes,
-  DEFAULT_MANIFEST_SPACE: () => import_sdk_core10.DEFAULT_MANIFEST_SPACE,
-  DEFAULT_MANIFEST_VERSION: () => import_sdk_core10.DEFAULT_MANIFEST_VERSION,
-  DEFAULT_SIGNED_READ_URL_EXPIRY_MS: () => import_sdk_core11.DEFAULT_SIGNED_READ_URL_EXPIRY_MS,
-  DataVaultService: () => import_sdk_core14.DataVaultService,
-  DatabaseHandle: () => import_sdk_core12.DatabaseHandle,
+  ACCOUNT_REGISTRY_PATH: () => import_sdk_core11.ACCOUNT_REGISTRY_PATH,
+  ACCOUNT_REGISTRY_SPACE: () => import_sdk_core11.ACCOUNT_REGISTRY_SPACE,
+  AccountService: () => import_sdk_core4.AccountService,
+  AutoApproveSpaceCreationHandler: () => import_sdk_core10.AutoApproveSpaceCreationHandler,
+  CapabilityKeyRegistry: () => import_sdk_core17.CapabilityKeyRegistry,
+  CapabilityKeyRegistryErrorCodes: () => import_sdk_core17.CapabilityKeyRegistryErrorCodes,
+  DEFAULT_MANIFEST_SPACE: () => import_sdk_core11.DEFAULT_MANIFEST_SPACE,
+  DEFAULT_MANIFEST_VERSION: () => import_sdk_core11.DEFAULT_MANIFEST_VERSION,
+  DEFAULT_SIGNED_READ_URL_EXPIRY_MS: () => import_sdk_core12.DEFAULT_SIGNED_READ_URL_EXPIRY_MS,
+  DataVaultService: () => import_sdk_core15.DataVaultService,
+  DatabaseHandle: () => import_sdk_core13.DatabaseHandle,
   DelegatedAccess: () => DelegatedAccess,
-  DelegationErrorCodes: () => import_sdk_core15.DelegationErrorCodes,
-  DelegationManager: () => import_sdk_core15.DelegationManager,
-  DuckDbAction: () => import_sdk_core13.DuckDbAction,
-  DuckDbDatabaseHandle: () => import_sdk_core13.DuckDbDatabaseHandle,
-  DuckDbService: () => import_sdk_core13.DuckDbService,
+  DelegationErrorCodes: () => import_sdk_core16.DelegationErrorCodes,
+  DelegationManager: () => import_sdk_core16.DelegationManager,
+  DuckDbAction: () => import_sdk_core14.DuckDbAction,
+  DuckDbDatabaseHandle: () => import_sdk_core14.DuckDbDatabaseHandle,
+  DuckDbService: () => import_sdk_core14.DuckDbService,
   FileSessionStorage: () => FileSessionStorage,
-  IdentityParseError: () => import_sdk_core9.IdentityParseError,
-  KVService: () => import_sdk_core11.KVService,
-  ManifestValidationError: () => import_sdk_core10.ManifestValidationError,
+  IdentityParseError: () => import_sdk_core10.IdentityParseError,
+  KVService: () => import_sdk_core12.KVService,
+  ManifestValidationError: () => import_sdk_core11.ManifestValidationError,
   MemorySessionStorage: () => MemorySessionStorage,
   NodeUserAuthorization: () => NodeUserAuthorization,
-  PermissionNotInManifestError: () => import_sdk_core10.PermissionNotInManifestError,
-  PrefixedKVService: () => import_sdk_core11.PrefixedKVService,
-  ProtocolMismatchError: () => import_sdk_core18.ProtocolMismatchError,
-  SECRET_NAME_RE: () => import_sdk_core14.SECRET_NAME_RE,
-  SQLAction: () => import_sdk_core12.SQLAction,
-  SQLService: () => import_sdk_core12.SQLService,
-  SecretsService: () => import_sdk_core14.SecretsService,
-  ServiceContext: () => import_sdk_core19.ServiceContext,
-  SessionExpiredError: () => import_sdk_core10.SessionExpiredError,
-  SharingService: () => import_sdk_core15.SharingService,
-  SilentNotificationHandler: () => import_sdk_core9.SilentNotificationHandler,
-  Space: () => import_sdk_core17.Space,
-  SpaceErrorCodes: () => import_sdk_core17.SpaceErrorCodes,
-  SpaceService: () => import_sdk_core17.SpaceService,
-  TinyCloud: () => import_sdk_core8.TinyCloud,
+  PermissionNotInManifestError: () => import_sdk_core11.PermissionNotInManifestError,
+  PrefixedKVService: () => import_sdk_core12.PrefixedKVService,
+  ProtocolMismatchError: () => import_sdk_core19.ProtocolMismatchError,
+  SECRET_NAME_RE: () => import_sdk_core15.SECRET_NAME_RE,
+  SQLAction: () => import_sdk_core13.SQLAction,
+  SQLService: () => import_sdk_core13.SQLService,
+  SecretsService: () => import_sdk_core15.SecretsService,
+  ServiceContext: () => import_sdk_core20.ServiceContext,
+  SessionExpiredError: () => import_sdk_core11.SessionExpiredError,
+  SharingService: () => import_sdk_core16.SharingService,
+  SilentNotificationHandler: () => import_sdk_core10.SilentNotificationHandler,
+  Space: () => import_sdk_core18.Space,
+  SpaceErrorCodes: () => import_sdk_core18.SpaceErrorCodes,
+  SpaceService: () => import_sdk_core18.SpaceService,
+  TinyCloud: () => import_sdk_core9.TinyCloud,
+  TinyCloudDebugLogger: () => import_sdk_core10.TinyCloudDebugLogger,
   TinyCloudNode: () => TinyCloudNode,
-  UnsupportedFeatureError: () => import_sdk_core18.UnsupportedFeatureError,
-  VAULT_PERMISSION_SERVICE: () => import_sdk_core10.VAULT_PERMISSION_SERVICE,
-  VaultHeaders: () => import_sdk_core14.VaultHeaders,
-  VaultPublicSpaceKVActions: () => import_sdk_core14.VaultPublicSpaceKVActions,
-  VersionCheckError: () => import_sdk_core18.VersionCheckError,
+  UnsupportedFeatureError: () => import_sdk_core19.UnsupportedFeatureError,
+  VAULT_PERMISSION_SERVICE: () => import_sdk_core11.VAULT_PERMISSION_SERVICE,
+  VaultHeaders: () => import_sdk_core15.VaultHeaders,
+  VaultPublicSpaceKVActions: () => import_sdk_core15.VaultPublicSpaceKVActions,
+  VersionCheckError: () => import_sdk_core19.VersionCheckError,
   WasmKeyProvider: () => WasmKeyProvider,
-  addressStorageKey: () => import_sdk_core9.addressStorageKey,
-  buildSpaceUri: () => import_sdk_core17.buildSpaceUri,
-  canonicalizeAddress: () => import_sdk_core9.canonicalizeAddress,
-  canonicalizeDid: () => import_sdk_core9.canonicalizeDid,
-  canonicalizeDidUrl: () => import_sdk_core9.canonicalizeDidUrl,
-  canonicalizeNetworkId: () => import_sdk_core9.canonicalizeNetworkId,
-  canonicalizeSecretScope: () => import_sdk_core14.canonicalizeSecretScope,
-  checkNodeInfo: () => import_sdk_core18.checkNodeInfo,
-  composeManifestRequest: () => import_sdk_core10.composeManifestRequest,
-  createCapabilityKeyRegistry: () => import_sdk_core16.createCapabilityKeyRegistry,
-  createSharingService: () => import_sdk_core15.createSharingService,
-  createSpaceService: () => import_sdk_core17.createSpaceService,
-  createVaultCrypto: () => import_sdk_core14.createVaultCrypto,
+  addressStorageKey: () => import_sdk_core10.addressStorageKey,
+  buildSpaceUri: () => import_sdk_core18.buildSpaceUri,
+  canonicalizeAddress: () => import_sdk_core10.canonicalizeAddress,
+  canonicalizeDid: () => import_sdk_core10.canonicalizeDid,
+  canonicalizeDidUrl: () => import_sdk_core10.canonicalizeDidUrl,
+  canonicalizeNetworkId: () => import_sdk_core10.canonicalizeNetworkId,
+  canonicalizeSecretScope: () => import_sdk_core15.canonicalizeSecretScope,
+  checkNodeInfo: () => import_sdk_core19.checkNodeInfo,
+  clearTinyCloudDebugLogs: () => import_sdk_core10.clearTinyCloudDebugLogs,
+  composeManifestRequest: () => import_sdk_core11.composeManifestRequest,
+  createCapabilityKeyRegistry: () => import_sdk_core17.createCapabilityKeyRegistry,
+  createOpenKeyCallbackSigningStrategy: () => import_sdk_core2.createOpenKeyCallbackSigningStrategy,
+  createSharingService: () => import_sdk_core16.createSharingService,
+  createSpaceService: () => import_sdk_core18.createSpaceService,
+  createVaultCrypto: () => import_sdk_core15.createVaultCrypto,
   createWasmKeyProvider: () => createWasmKeyProvider,
   defaultSignStrategy: () => defaultSignStrategy,
-  defaultSpaceCreationHandler: () => import_sdk_core9.defaultSpaceCreationHandler,
+  defaultSpaceCreationHandler: () => import_sdk_core10.defaultSpaceCreationHandler,
   deserializeDelegation: () => deserializeDelegation,
-  didCacheKey: () => import_sdk_core9.didCacheKey,
-  didEquals: () => import_sdk_core9.didEquals,
-  expandActionShortNames: () => import_sdk_core10.expandActionShortNames,
-  expandPermissionEntries: () => import_sdk_core10.expandPermissionEntries,
-  expandPermissionEntry: () => import_sdk_core10.expandPermissionEntry,
-  isCapabilitySubset: () => import_sdk_core10.isCapabilitySubset,
-  isEvmAddress: () => import_sdk_core9.isEvmAddress,
-  loadManifest: () => import_sdk_core10.loadManifest,
-  makePkhSpaceId: () => import_sdk_core9.makePkhSpaceId,
-  makePublicSpaceId: () => import_sdk_core17.makePublicSpaceId,
-  parseCanonicalNetworkId: () => import_sdk_core9.parseCanonicalNetworkId,
-  parseExpiry: () => import_sdk_core10.parseExpiry,
-  parsePkhDid: () => import_sdk_core9.parsePkhDid,
-  parseSpaceUri: () => import_sdk_core17.parseSpaceUri,
-  pkhDid: () => import_sdk_core9.pkhDid,
-  principalDid: () => import_sdk_core9.principalDid,
-  principalDidEquals: () => import_sdk_core9.principalDidEquals,
-  resolveManifest: () => import_sdk_core10.resolveManifest,
-  resolveSecretListPrefix: () => import_sdk_core14.resolveSecretListPrefix,
-  resolveSecretPath: () => import_sdk_core14.resolveSecretPath,
-  resourceCapabilitiesToSpaceAbilitiesMap: () => import_sdk_core10.resourceCapabilitiesToSpaceAbilitiesMap,
+  didCacheKey: () => import_sdk_core10.didCacheKey,
+  didEquals: () => import_sdk_core10.didEquals,
+  disableTinyCloudDebug: () => import_sdk_core10.disableTinyCloudDebug,
+  enableTinyCloudDebug: () => import_sdk_core10.enableTinyCloudDebug,
+  expandActionShortNames: () => import_sdk_core11.expandActionShortNames,
+  expandPermissionEntries: () => import_sdk_core11.expandPermissionEntries,
+  expandPermissionEntry: () => import_sdk_core11.expandPermissionEntry,
+  getTinyCloudDebugLogs: () => import_sdk_core10.getTinyCloudDebugLogs,
+  installTinyCloudDebugGlobals: () => import_sdk_core10.installTinyCloudDebugGlobals,
+  isCapabilitySubset: () => import_sdk_core11.isCapabilitySubset,
+  isEvmAddress: () => import_sdk_core10.isEvmAddress,
+  loadManifest: () => import_sdk_core11.loadManifest,
+  makePkhSpaceId: () => import_sdk_core10.makePkhSpaceId,
+  makePublicSpaceId: () => import_sdk_core18.makePublicSpaceId,
+  parseCanonicalNetworkId: () => import_sdk_core10.parseCanonicalNetworkId,
+  parseExpiry: () => import_sdk_core11.parseExpiry,
+  parsePkhDid: () => import_sdk_core10.parsePkhDid,
+  parseSpaceUri: () => import_sdk_core18.parseSpaceUri,
+  pkhDid: () => import_sdk_core10.pkhDid,
+  principalDid: () => import_sdk_core10.principalDid,
+  principalDidEquals: () => import_sdk_core10.principalDidEquals,
+  resolveManifest: () => import_sdk_core11.resolveManifest,
+  resolveSecretListPrefix: () => import_sdk_core15.resolveSecretListPrefix,
+  resolveSecretPath: () => import_sdk_core15.resolveSecretPath,
+  resourceCapabilitiesToSpaceAbilitiesMap: () => import_sdk_core11.resourceCapabilitiesToSpaceAbilitiesMap,
   serializeDelegation: () => serializeDelegation,
-  validateManifest: () => import_sdk_core10.validateManifest
+  tinyCloudDebugLogger: () => import_sdk_core10.tinyCloudDebugLogger,
+  validateManifest: () => import_sdk_core11.validateManifest
 });
 module.exports = __toCommonJS(core_exports);
-var import_sdk_core8 = require("@tinycloud/sdk-core");
 var import_sdk_core9 = require("@tinycloud/sdk-core");
+var import_sdk_core10 = require("@tinycloud/sdk-core");
 
 // src/storage/MemorySessionStorage.ts
 var MemorySessionStorage = class {
@@ -312,9 +320,10 @@ var FileSessionStorage = class {
 };
 
 // src/authorization/NodeUserAuthorization.ts
-var import_sdk_core2 = require("@tinycloud/sdk-core");
+var import_sdk_core3 = require("@tinycloud/sdk-core");
 
 // src/authorization/strategies.ts
+var import_sdk_core2 = require("@tinycloud/sdk-core");
 var defaultSignStrategy = { type: "auto-sign" };
 
 // src/authorization/NodeUserAuthorization.ts
@@ -322,7 +331,7 @@ var DECRYPT_ACTION = "tinycloud.encryption/decrypt";
 var NETWORK_CREATE_ACTION = "tinycloud.encryption/network.create";
 function didPrincipalMatches(actual, expected) {
   try {
-    return (0, import_sdk_core2.principalDidEquals)(actual, expected);
+    return (0, import_sdk_core3.principalDidEquals)(actual, expected);
   } catch {
     return actual === expected;
   }
@@ -341,6 +350,7 @@ var NodeUserAuthorization = class {
   constructor(config) {
     this.extensions = [];
     this._nodeFeatures = [];
+    this._lastActivationSkippedSpaceIds = [];
     this.wasm = config.wasmBindings;
     this.signer = config.signer;
     this.signStrategy = config.signStrategy ?? defaultSignStrategy;
@@ -363,7 +373,7 @@ var NodeUserAuthorization = class {
         "": [
           "tinycloud.sql/read",
           "tinycloud.sql/write",
-          "tinycloud.sql/ddl",
+          "tinycloud.sql/schema",
           "tinycloud.sql/admin",
           "tinycloud.sql/export"
         ]
@@ -391,7 +401,7 @@ var NodeUserAuthorization = class {
         ]
       }
     };
-    this.sessionExpirationMs = config.sessionExpirationMs ?? import_sdk_core2.EXPIRY.SESSION_MS;
+    this.sessionExpirationMs = config.sessionExpirationMs ?? import_sdk_core3.EXPIRY.SESSION_MS;
     this.autoCreateSpace = config.autoCreateSpace ?? false;
     this.spaceCreationHandler = config.spaceCreationHandler;
     this.tinycloudHosts = config.tinycloudHosts;
@@ -455,19 +465,55 @@ var NodeUserAuthorization = class {
    * `siwe` is the load-bearing one because `extractSiweExpiration` returns
    * undefined for missing SIWEs and the SDK then treats the session as
    * expired-at-epoch-zero.
+   *
+   * @param hosts - The TinyCloud hosts this session was created against,
+   *   as persisted in {@link PersistedSessionData.tinycloudHosts}. When
+   *   present (and non-empty) they are adopted directly so the restored
+   *   session resolves to the same node as the original sign-in without
+   *   re-running registry/fallback resolution. When absent (old session)
+   *   hosts are resolved lazily on the first host-needing call via
+   *   {@link ensureTinyCloudHosts}.
    */
-  setRestoredTinyCloudSession(session) {
-    const address = (0, import_sdk_core2.canonicalizeAddress)(session.address);
+  setRestoredTinyCloudSession(session, hosts) {
+    const address = (0, import_sdk_core3.canonicalizeAddress)(session.address);
     this._tinyCloudSession = { ...session, address };
     this._address = address;
     this._chainId = session.chainId;
+    if ((!this.tinycloudHosts || this.tinycloudHosts.length === 0) && hosts && hosts.length > 0) {
+      this.tinycloudHosts = [...hosts];
+    }
+  }
+  /**
+   * Ensure `tinycloudHosts` are resolved before a host-needing call.
+   *
+   * Fresh sign-in resolves hosts up front; a restored session may not have
+   * (old persisted sessions predate {@link PersistedSessionData.tinycloudHosts}).
+   * This guard makes a restored session resolve the node exactly like a fresh
+   * sign-in — persisted hosts are preferred (already set by
+   * {@link setRestoredTinyCloudSession}), otherwise the registry/fallback
+   * resolution runs lazily here. Idempotent: {@link resolveTinyCloudHostsForSignIn}
+   * early-returns when hosts are already set.
+   *
+   * Throws if hosts are unset and the restored session has no address/chainId
+   * to resolve from — a real failure that must surface, not be masked.
+   */
+  async ensureTinyCloudHosts() {
+    if (this.tinycloudHosts && this.tinycloudHosts.length > 0) {
+      return;
+    }
+    if (this._address === void 0 || this._chainId === void 0) {
+      throw new Error(
+        "Cannot resolve TinyCloud hosts: no address/chainId available. Sign in or restore a session first."
+      );
+    }
+    await this.resolveTinyCloudHostsForSignIn(this._address, this._chainId);
   }
   async resolveTinyCloudHostsForSignIn(address, chainId) {
     if (this.tinycloudHosts && this.tinycloudHosts.length > 0) {
       return;
     }
-    const subject = (0, import_sdk_core2.pkhDid)(address, chainId);
-    const resolved = await (0, import_sdk_core2.resolveTinyCloudHosts)(subject, {
+    const subject = (0, import_sdk_core3.pkhDid)(address, chainId);
+    const resolved = await (0, import_sdk_core3.resolveTinyCloudHosts)(subject, {
       registryUrl: this.tinycloudRegistryUrl,
       fallbackHosts: this.tinycloudFallbackHosts
     });
@@ -485,6 +531,9 @@ var NodeUserAuthorization = class {
   get nodeFeatures() {
     return this._nodeFeatures;
   }
+  get lastActivationSkippedSpaceIds() {
+    return [...this._lastActivationSkippedSpaceIds];
+  }
   /**
    * Compute the `abilities` map the WASM `prepareSession` call should
    * see at sign-in time.
@@ -518,7 +567,7 @@ var NodeUserAuthorization = class {
     if (this._manifest === void 0) {
       return void 0;
     }
-    this._capabilityRequest = (0, import_sdk_core2.composeManifestRequest)(
+    this._capabilityRequest = (0, import_sdk_core3.composeManifestRequest)(
       Array.isArray(this._manifest) ? this._manifest : [this._manifest],
       {
         includeAccountRegistryPermissions: this.includeAccountRegistryPermissions
@@ -530,17 +579,17 @@ var NodeUserAuthorization = class {
     if (space.startsWith("tinycloud:")) {
       return space;
     }
-    return (0, import_sdk_core2.makePkhSpaceId)(address, chainId, space);
+    return (0, import_sdk_core3.makePkhSpaceId)(address, chainId, space);
   }
   defaultEncryptionNetworkId(address, chainId) {
-    return `urn:tinycloud:encryption:${(0, import_sdk_core2.pkhDid)(address, chainId)}:default`;
+    return `urn:tinycloud:encryption:${(0, import_sdk_core3.pkhDid)(address, chainId)}:default`;
   }
   resolveSignInCapabilities(address, chainId) {
     const request = this.getCapabilityRequest();
     if (request === void 0) {
       const defaultNetworkId = this.defaultEncryptionNetworkId(address, chainId);
-      const primarySpaceId2 = (0, import_sdk_core2.makePkhSpaceId)(address, chainId, this.spacePrefix);
-      const secretsSpaceId = (0, import_sdk_core2.makePkhSpaceId)(address, chainId, "secrets");
+      const primarySpaceId2 = (0, import_sdk_core3.makePkhSpaceId)(address, chainId, this.spacePrefix);
+      const secretsSpaceId = (0, import_sdk_core3.makePkhSpaceId)(address, chainId, "secrets");
       return {
         abilities: this.defaultActions,
         spaceId: primarySpaceId2,
@@ -567,35 +616,35 @@ var NodeUserAuthorization = class {
       };
     }
     const rawAbilities = {};
-    const currentDid = (0, import_sdk_core2.pkhDid)(address, chainId);
+    const currentDid = (0, import_sdk_core3.pkhDid)(address, chainId);
     const spaceResources = request.resources.filter((entry) => {
-      if (entry.service !== import_sdk_core2.ENCRYPTION_PERMISSION_SERVICE) {
+      if (entry.service !== import_sdk_core3.ENCRYPTION_PERMISSION_SERVICE) {
         return true;
       }
       for (const action of entry.actions) {
         addRawAbility(rawAbilities, entry.path, action);
       }
       if (entry.actions.includes(DECRYPT_ACTION)) {
-        const parsed = (0, import_sdk_core2.parseNetworkId)(entry.path);
+        const parsed = (0, import_sdk_core3.parseNetworkId)(entry.path);
         if (didPrincipalMatches(parsed.ownerDid, currentDid)) {
           addRawAbility(rawAbilities, entry.path, NETWORK_CREATE_ACTION);
         }
       }
       return false;
     });
-    const primarySpaceName = spaceResources.find((entry) => entry.space !== "account")?.space ?? import_sdk_core2.DEFAULT_MANIFEST_SPACE;
+    const primarySpaceName = spaceResources.find((entry) => entry.space !== "account")?.space ?? import_sdk_core3.DEFAULT_MANIFEST_SPACE;
     const primarySpaceId = this.resolveSpaceName(
       primarySpaceName,
       address,
       chainId
     );
-    const bySpace = (0, import_sdk_core2.resourceCapabilitiesToSpaceAbilitiesMap)(spaceResources);
+    const bySpace = (0, import_sdk_core3.resourceCapabilitiesToSpaceAbilitiesMap)(spaceResources);
     const spaceAbilities = {};
     for (const [space, abilities] of Object.entries(bySpace)) {
       spaceAbilities[this.resolveSpaceName(space, address, chainId)] = abilities;
     }
     return {
-      abilities: spaceAbilities[primarySpaceId] ?? (0, import_sdk_core2.resourceCapabilitiesToAbilitiesMap)([]),
+      abilities: spaceAbilities[primarySpaceId] ?? (0, import_sdk_core3.resourceCapabilitiesToAbilitiesMap)([]),
       spaceId: primarySpaceId,
       spaceAbilities,
       rawAbilities: Object.keys(rawAbilities).length > 0 ? rawAbilities : void 0
@@ -657,9 +706,10 @@ var NodeUserAuthorization = class {
     if (!this._tinyCloudSession || !this._address || !this._chainId) {
       throw new Error("Must be signed in to host space");
     }
+    await this.ensureTinyCloudHosts();
     const host = this.primaryTinyCloudHost;
     const spaceId = targetSpaceId ?? this._tinyCloudSession.spaceId;
-    const peerId = await (0, import_sdk_core2.fetchPeerId)(host, spaceId);
+    const peerId = await (0, import_sdk_core3.fetchPeerId)(host, spaceId);
     const siwe = this.wasm.generateHostSIWEMessage({
       address: this._address,
       chainId: this._chainId,
@@ -670,7 +720,7 @@ var NodeUserAuthorization = class {
     });
     const signature = await this.signMessage(siwe);
     const headers = this.wasm.siweToDelegationHeaders({ siwe, signature });
-    const result = await (0, import_sdk_core2.submitHostDelegation)(host, headers);
+    const result = await (0, import_sdk_core3.submitHostDelegation)(host, headers);
     return result.success;
   }
   /**
@@ -699,13 +749,15 @@ var NodeUserAuthorization = class {
     if (!this._tinyCloudSession) {
       throw new Error("Must be signed in to ensure space exists");
     }
+    await this.ensureTinyCloudHosts();
     const host = this.primaryTinyCloudHost;
     const primarySpaceId = this._tinyCloudSession.spaceId;
-    const result = await (0, import_sdk_core2.activateSessionWithHost)(
+    const result = await (0, import_sdk_core3.activateSessionWithHost)(
       host,
       this._tinyCloudSession.delegationHeader
     );
-    const handler = this.spaceCreationHandler ?? (this.autoCreateSpace ? new import_sdk_core2.AutoApproveSpaceCreationHandler() : void 0);
+    this.recordActivationSkippedSpaces(result, primarySpaceId);
+    const handler = this.spaceCreationHandler ?? (this.autoCreateSpace ? new import_sdk_core3.AutoApproveSpaceCreationHandler() : void 0);
     const creationContext = {
       spaceId: primarySpaceId,
       address: this._address,
@@ -739,7 +791,7 @@ var NodeUserAuthorization = class {
         throw error;
       }
       await new Promise((resolve) => setTimeout(resolve, 100));
-      const retryResult = await (0, import_sdk_core2.activateSessionWithHost)(
+      const retryResult = await (0, import_sdk_core3.activateSessionWithHost)(
         host,
         this._tinyCloudSession.delegationHeader
       );
@@ -776,7 +828,7 @@ var NodeUserAuthorization = class {
         throw error;
       }
       await new Promise((resolve) => setTimeout(resolve, 100));
-      const retryResult = await (0, import_sdk_core2.activateSessionWithHost)(
+      const retryResult = await (0, import_sdk_core3.activateSessionWithHost)(
         host,
         this._tinyCloudSession.delegationHeader
       );
@@ -792,6 +844,66 @@ var NodeUserAuthorization = class {
     }
     throw new Error(`Failed to activate session: ${result.error}`);
   }
+  recordActivationSkippedSpaces(result, primarySpaceId) {
+    if (result.success) {
+      this._lastActivationSkippedSpaceIds = result.skipped ?? [];
+      return;
+    }
+    this._lastActivationSkippedSpaceIds = result.status === 404 ? [primarySpaceId] : [];
+  }
+  async createBootstrapSession(options) {
+    if (!this._address || !this._chainId) {
+      throw new Error("Must be signed in before creating bootstrap sessions");
+    }
+    const address = this._address;
+    const chainId = this._chainId;
+    const keyId = `bootstrap-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    this.sessionManager.createSessionKey(keyId);
+    const jwkString = this.sessionManager.jwk(keyId);
+    if (!jwkString) {
+      throw new Error("Failed to create bootstrap session key");
+    }
+    const jwk = JSON.parse(jwkString);
+    const now = /* @__PURE__ */ new Date();
+    const expirationTime = new Date(now.getTime() + this.sessionExpirationMs);
+    const abilities = (0, import_sdk_core3.resourceCapabilitiesToAbilitiesMap)(
+      options.capabilityRequest.resources
+    );
+    const prepared = this.wasm.prepareSession({
+      abilities,
+      ...options.rawAbilities !== void 0 ? { rawAbilities: options.rawAbilities } : {},
+      address,
+      chainId,
+      domain: this.domain,
+      issuedAt: now.toISOString(),
+      expirationTime: expirationTime.toISOString(),
+      spaceId: options.spaceId,
+      jwk,
+      ...this.buildSiweOverrides()
+    });
+    const signature = await this.requestSignature({
+      address,
+      chainId,
+      message: prepared.siwe,
+      type: "siwe"
+    });
+    const session = this.wasm.completeSessionSetup({
+      ...prepared,
+      signature
+    });
+    return {
+      address,
+      chainId,
+      sessionKey: keyId,
+      spaceId: options.spaceId,
+      delegationCid: session.delegationCid,
+      delegationHeader: session.delegationHeader,
+      verificationMethod: this.sessionManager.getDID(keyId),
+      jwk,
+      siwe: prepared.siwe,
+      signature
+    };
+  }
   /**
    * Sign in and create a new session.
    *
@@ -804,7 +916,7 @@ var NodeUserAuthorization = class {
    * @param options - Optional per-call SIWE overrides for this sign-in only
    */
   async signIn(options) {
-    this._address = (0, import_sdk_core2.canonicalizeAddress)(await this.signer.getAddress());
+    this._address = (0, import_sdk_core3.canonicalizeAddress)(await this.signer.getAddress());
     this._chainId = await this.signer.getChainId();
     const address = this._address;
     const chainId = this._chainId;
@@ -851,7 +963,7 @@ var NodeUserAuthorization = class {
       siwe: prepared.siwe,
       signature
     };
-    const spacesMetadata = this.enablePublicSpace ? { public: (0, import_sdk_core2.makePkhSpaceId)(address, chainId, "public") } : void 0;
+    const spacesMetadata = this.enablePublicSpace ? { public: (0, import_sdk_core3.makePkhSpaceId)(address, chainId, "public") } : void 0;
     const tinyCloudSession = {
       address,
       chainId,
@@ -880,14 +992,15 @@ var NodeUserAuthorization = class {
       },
       expiresAt: expirationTime.toISOString(),
       createdAt: now.toISOString(),
-      version: "1.0"
+      version: "1.0",
+      tinycloudHosts: this.tinycloudHosts
     };
     await this.sessionStorage.save(address, persistedData);
     this._session = clientSession;
     this._tinyCloudSession = tinyCloudSession;
     this._address = address;
     this._chainId = chainId;
-    const nodeInfo = await (0, import_sdk_core2.checkNodeInfo)(
+    const nodeInfo = await (0, import_sdk_core3.checkNodeInfo)(
       this.primaryTinyCloudHost,
       this.wasm.protocolVersion()
     );
@@ -926,7 +1039,7 @@ var NodeUserAuthorization = class {
    */
   async signMessage(message) {
     if (!this._address) {
-      this._address = (0, import_sdk_core2.canonicalizeAddress)(await this.signer.getAddress());
+      this._address = (0, import_sdk_core3.canonicalizeAddress)(await this.signer.getAddress());
     }
     if (!this._chainId) {
       this._chainId = await this.signer.getChainId();
@@ -953,7 +1066,7 @@ var NodeUserAuthorization = class {
    * ```
    */
   async prepareSessionForSigning() {
-    const address = (0, import_sdk_core2.canonicalizeAddress)(await this.signer.getAddress());
+    const address = (0, import_sdk_core3.canonicalizeAddress)(await this.signer.getAddress());
     const chainId = await this.signer.getChainId();
     const keyId = `session-${Date.now()}`;
     this.sessionManager.renameSessionKeyId("default", keyId);
@@ -1003,7 +1116,7 @@ var NodeUserAuthorization = class {
       ...prepared,
       signature
     });
-    const address = (0, import_sdk_core2.canonicalizeAddress)(await this.signer.getAddress());
+    const address = (0, import_sdk_core3.canonicalizeAddress)(await this.signer.getAddress());
     const chainId = await this.signer.getChainId();
     await this.resolveTinyCloudHostsForSignIn(address, chainId);
     const clientSession = {
@@ -1014,7 +1127,7 @@ var NodeUserAuthorization = class {
       siwe: prepared.siwe,
       signature
     };
-    const spacesMetadata = this.enablePublicSpace ? { public: (0, import_sdk_core2.makePkhSpaceId)(address, chainId, "public") } : void 0;
+    const spacesMetadata = this.enablePublicSpace ? { public: (0, import_sdk_core3.makePkhSpaceId)(address, chainId, "public") } : void 0;
     const tinyCloudSession = {
       address,
       chainId,
@@ -1047,14 +1160,15 @@ var NodeUserAuthorization = class {
       },
       expiresAt,
       createdAt,
-      version: "1.0"
+      version: "1.0",
+      tinycloudHosts: this.tinycloudHosts
     };
     await this.sessionStorage.save(address, persistedData);
     this._session = clientSession;
     this._tinyCloudSession = tinyCloudSession;
     this._address = address;
     this._chainId = chainId;
-    const nodeInfo = await (0, import_sdk_core2.checkNodeInfo)(
+    const nodeInfo = await (0, import_sdk_core3.checkNodeInfo)(
       this.primaryTinyCloudHost,
       this.wasm.protocolVersion()
     );
@@ -1138,35 +1252,36 @@ var NodeUserAuthorization = class {
 };
 
 // src/TinyCloudNode.ts
-var import_sdk_core7 = require("@tinycloud/sdk-core");
+var import_sdk_core8 = require("@tinycloud/sdk-core");
 
 // src/account/AccountService.ts
-var import_sdk_core3 = require("@tinycloud/sdk-core");
+var import_sdk_core4 = require("@tinycloud/sdk-core");
 
 // src/DelegatedAccess.ts
-var import_sdk_core4 = require("@tinycloud/sdk-core");
+var import_sdk_core5 = require("@tinycloud/sdk-core");
 var DelegatedAccess = class {
-  constructor(session, delegation, host, invoke, telemetry) {
+  constructor(session, delegation, host, invoke, invokeAny, telemetry) {
     this.session = session;
     this._delegation = delegation;
     this.host = host;
-    this._serviceContext = new import_sdk_core4.ServiceContext({
+    this._serviceContext = new import_sdk_core5.ServiceContext({
       invoke,
+      invokeAny,
       fetch: globalThis.fetch.bind(globalThis),
       hosts: [host],
       telemetry
     });
     const prefix = this._delegation.path.replace(/\/$/, "");
-    this._kv = new import_sdk_core4.KVService({ prefix });
+    this._kv = new import_sdk_core5.KVService({ prefix });
     this._kv.initialize(this._serviceContext);
     this._serviceContext.registerService("kv", this._kv);
-    this._sql = new import_sdk_core4.SQLService({});
+    this._sql = new import_sdk_core5.SQLService({});
     this._sql.initialize(this._serviceContext);
     this._serviceContext.registerService("sql", this._sql);
-    this._duckdb = new import_sdk_core4.DuckDbService({});
+    this._duckdb = new import_sdk_core5.DuckDbService({});
     this._duckdb.initialize(this._serviceContext);
     this._serviceContext.registerService("duckdb", this._duckdb);
-    this._hooks = new import_sdk_core4.HooksService({});
+    this._hooks = new import_sdk_core5.HooksService({});
     this._hooks.initialize(this._serviceContext);
     this._serviceContext.registerService("hooks", this._hooks);
     const serviceSession = {
@@ -1316,7 +1431,7 @@ function createWasmKeyProvider(sessionManager) {
 }
 
 // src/delegateToHelpers.ts
-var import_sdk_core5 = require("@tinycloud/sdk-core");
+var import_sdk_core6 = require("@tinycloud/sdk-core");
 function legacyParamsToPermissionEntries(actions, path, spaceIdOverride) {
   const byService = /* @__PURE__ */ new Map();
   for (const a of actions) {
@@ -1347,7 +1462,7 @@ function legacyParamsToPermissionEntries(actions, path, spaceIdOverride) {
   }
   return entries;
 }
-var DEFAULT_DELEGATION_EXPIRY_MS = import_sdk_core5.EXPIRY.SESSION_MS;
+var DEFAULT_DELEGATION_EXPIRY_MS = import_sdk_core6.EXPIRY.SESSION_MS;
 function resolveExpiryMs(expiry) {
   if (expiry === void 0) {
     return DEFAULT_DELEGATION_EXPIRY_MS;
@@ -1360,10 +1475,10 @@ function resolveExpiryMs(expiry) {
     }
     return expiry;
   }
-  return (0, import_sdk_core5.parseExpiry)(expiry);
+  return (0, import_sdk_core6.parseExpiry)(expiry);
 }
 function extractSiweExpiration(siwe) {
-  const parsed = new import_sdk_core5.SiweMessage(siwe);
+  const parsed = new import_sdk_core6.SiweMessage(siwe);
   if (parsed.expirationTime === void 0 || parsed.expirationTime === null) {
     return void 0;
   }
@@ -1377,7 +1492,7 @@ function extractSiweExpiration(siwe) {
 }
 
 // src/NodeSecretsService.ts
-var import_sdk_core6 = require("@tinycloud/sdk-core");
+var import_sdk_core7 = require("@tinycloud/sdk-core");
 var SECRETS_SPACE = "secrets";
 function ok() {
   return { ok: true, data: void 0 };
@@ -1410,7 +1525,7 @@ function secretActionName(action) {
 }
 function secretPermissionEntries(name, options, action, encryptionNetworkId) {
   const entries = [];
-  const path = action === "list" ? (0, import_sdk_core6.resolveSecretListPrefix)(options) : (0, import_sdk_core6.resolveSecretPath)(name, options).permissionPaths.vault;
+  const path = action === "list" ? (0, import_sdk_core7.resolveSecretListPrefix)(options) : (0, import_sdk_core7.resolveSecretPath)(name, options).permissionPaths.vault;
   entries.push({
     service: "tinycloud.kv",
     space: SECRETS_SPACE,
@@ -1489,7 +1604,7 @@ var NodeSecretsService = class {
       );
     } catch (error) {
       return secretsError(
-        import_sdk_core6.ErrorCodes.INVALID_INPUT,
+        import_sdk_core7.ErrorCodes.INVALID_INPUT,
         error instanceof Error ? error.message : String(error),
         error instanceof Error ? error : void 0
       );
@@ -1499,7 +1614,7 @@ var NodeSecretsService = class {
     }
     if (!this.config.canEscalate()) {
       return secretsError(
-        import_sdk_core6.ErrorCodes.PERMISSION_DENIED,
+        import_sdk_core7.ErrorCodes.PERMISSION_DENIED,
         `Cannot autosign ${displayActionUrn(action)} for ${target}; TinyCloudNode needs wallet mode with a signer or privateKey.`
       );
     }
@@ -1508,7 +1623,7 @@ var NodeSecretsService = class {
       return this.restoreUnlockAfterEscalation();
     } catch (error) {
       return secretsError(
-        import_sdk_core6.ErrorCodes.PERMISSION_DENIED,
+        import_sdk_core7.ErrorCodes.PERMISSION_DENIED,
         error instanceof Error ? error.message : `Autosign escalation for ${displayActionUrn(action)} on ${target} failed.`,
         error instanceof Error ? error : void 0
       );
@@ -1529,10 +1644,10 @@ var NodeSecretsService = class {
       return false;
     }
     const manifests = Array.isArray(manifest) ? manifest : [manifest];
-    const requestedEntries = (0, import_sdk_core6.expandPermissionEntries)(permissionEntries);
+    const requestedEntries = (0, import_sdk_core7.expandPermissionEntries)(permissionEntries);
     return requestedEntries.every(
       (entry) => manifests.some((candidate) => {
-        const resolved = (0, import_sdk_core6.resolveManifest)(candidate);
+        const resolved = (0, import_sdk_core7.resolveManifest)(candidate);
         return resolved.resources.some(
           (resource) => resource.service === entry.service && resource.space === entry.space && resource.path === entry.path && entry.actions.every((action) => resource.actions.includes(action))
         );
@@ -1547,10 +1662,13 @@ var DEFAULT_ENCRYPTION_NETWORK_NAME = "default";
 var NETWORK_CREATE_ACTION2 = "tinycloud.encryption/network.create";
 var DECRYPT_ACTION2 = "tinycloud.encryption/decrypt";
 var NETWORK_ADMIN_TYPE = "tinycloud.encryption.network-admin/v1";
-var DEFAULT_SESSION_EXPIRATION_MS = import_sdk_core7.EXPIRY.SESSION_MS;
+var DEFAULT_SESSION_EXPIRATION_MS = import_sdk_core8.EXPIRY.SESSION_MS;
+function isOpenKeyAutoSignStrategy(strategy) {
+  return strategy?.openKeyAutoSign === true;
+}
 function didPrincipalMatches2(actual, expected) {
   try {
-    return (0, import_sdk_core7.principalDidEquals)(actual, expected);
+    return (0, import_sdk_core8.principalDidEquals)(actual, expected);
   } catch {
     return actual === expected;
   }
@@ -1716,12 +1834,12 @@ var _TinyCloudNode = class _TinyCloudNode {
       throw new Error("Failed to get session key JWK");
     }
     this.sessionKeyJwk = JSON.parse(jwkStr);
-    this._capabilityRegistry = new import_sdk_core7.CapabilityKeyRegistry();
+    this._capabilityRegistry = new import_sdk_core8.CapabilityKeyRegistry();
     this._keyProvider = new WasmKeyProvider({
       sessionManager: this.sessionManager
     });
-    this.notificationHandler = config.notificationHandler ?? new import_sdk_core7.SilentNotificationHandler();
-    this._sharingService = new import_sdk_core7.SharingService({
+    this.notificationHandler = config.notificationHandler ?? new import_sdk_core8.SilentNotificationHandler();
+    this._sharingService = new import_sdk_core8.SharingService({
       hosts: [this.config.host],
       // session: undefined - not needed for receive()
       invoke: this.invokeWithRuntimePermissions,
@@ -1731,8 +1849,8 @@ var _TinyCloudNode = class _TinyCloudNode {
       // delegationManager: undefined - not needed for receive()
       createKVService: (config2) => {
         const prefix = config2.pathPrefix?.replace(/\/$/, "");
-        const kvService = new import_sdk_core7.KVService({ prefix });
-        const kvContext = new import_sdk_core7.ServiceContext({
+        const kvService = new import_sdk_core8.KVService({ prefix });
+        const kvContext = new import_sdk_core8.ServiceContext({
           invoke: config2.invoke,
           fetch: config2.fetch ?? globalThis.fetch.bind(globalThis),
           hosts: config2.hosts,
@@ -1772,9 +1890,10 @@ var _TinyCloudNode = class _TinyCloudNode {
    * @internal
    */
   setupAuth(config) {
+    const useBootstrapSignInRequest = this.shouldUseBootstrapSignInRequest(config);
     this.auth = new NodeUserAuthorization({
       signer: this.signer,
-      signStrategy: { type: "auto-sign" },
+      signStrategy: config.signStrategy ?? { type: "auto-sign" },
       wasmBindings: this.wasmBindings,
       sessionStorage: config.sessionStorage ?? new MemorySessionStorage(),
       domain: this.siweDomain,
@@ -1783,20 +1902,23 @@ var _TinyCloudNode = class _TinyCloudNode {
       tinycloudHosts: this.explicitHost ? [this.explicitHost] : void 0,
       tinycloudRegistryUrl: config.tinycloudRegistryUrl,
       tinycloudFallbackHosts: config.tinycloudFallbackHosts,
-      autoCreateSpace: config.autoCreateSpace,
+      autoCreateSpace: useBootstrapSignInRequest ? false : config.autoCreateSpace,
       enablePublicSpace: config.enablePublicSpace ?? true,
-      spaceCreationHandler: config.spaceCreationHandler,
+      spaceCreationHandler: useBootstrapSignInRequest ? void 0 : config.spaceCreationHandler,
       nonce: config.nonce,
       siweConfig: config.siweConfig,
-      manifest: config.manifest,
-      capabilityRequest: config.capabilityRequest,
-      includeAccountRegistryPermissions: config.includeAccountRegistryPermissions
+      manifest: useBootstrapSignInRequest ? void 0 : config.manifest,
+      capabilityRequest: useBootstrapSignInRequest ? import_sdk_core8.BOOTSTRAP_SESSION_REQUESTS.default : config.capabilityRequest,
+      includeAccountRegistryPermissions: useBootstrapSignInRequest ? false : config.includeAccountRegistryPermissions
     });
-    this.tc = new import_sdk_core7.TinyCloud(this.auth, {
+    this.tc = new import_sdk_core8.TinyCloud(this.auth, {
       invokeAny: this.invokeAnyWithRuntimePermissions,
       telemetry: config.telemetry
     });
   }
+  shouldUseBootstrapSignInRequest(config) {
+    return config.autoBootstrapAccount !== false && config.manifest === void 0 && config.capabilityRequest === void 0 && (config.prefix ?? "default") === "default" && isOpenKeyAutoSignStrategy(config.signStrategy);
+  }
   syncResolvedHostFromAuth() {
     const host = this.auth?.hosts[0];
     if (host) {
@@ -1853,7 +1975,7 @@ var _TinyCloudNode = class _TinyCloudNode {
    */
   get did() {
     if (this._address) {
-      return (0, import_sdk_core7.pkhDid)(this._address, this._chainId);
+      return (0, import_sdk_core8.pkhDid)(this._address, this._chainId);
     }
     return this.sessionManager.getDID(this.sessionKeyId);
   }
@@ -1895,14 +2017,14 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!this._address) {
       return void 0;
     }
-    return this.wasmBindings.makeSpaceId(this._address, this._chainId, import_sdk_core7.ACCOUNT_REGISTRY_SPACE);
+    return this.wasmBindings.makeSpaceId(this._address, this._chainId, import_sdk_core8.ACCOUNT_REGISTRY_SPACE);
   }
   /**
    * Account-level application and delegation helpers.
    */
   get account() {
     if (!this._account) {
-      this._account = new import_sdk_core3.AccountService({
+      this._account = new import_sdk_core4.AccountService({
         getDid: () => this.did,
         getHost: () => this.hosts[0] ?? this.config.host,
         getPrimarySpaceId: () => this.spaceId,
@@ -1911,7 +2033,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         getAccountDb: () => this.accountSpaceId ? this.sqlForSpace(this.accountSpaceId).db("account") : void 0,
         ensureAccountSpaceHosted: async () => {
           if (this.accountSpaceId && this.auth) {
-            await this.ensureOwnedSpaceHosted(this.accountSpaceId);
+            await this.ensureOwnedSpaceHostedById(this.accountSpaceId);
           }
         }
       });
@@ -1939,7 +2061,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       );
     }
     await this.wasmBindings.ensureInitialized?.();
-    this._address = (0, import_sdk_core7.canonicalizeAddress)(await this.signer.getAddress());
+    this._address = (0, import_sdk_core8.canonicalizeAddress)(await this.signer.getAddress());
     this._chainId = await this.signer.getChainId();
     this._kv = void 0;
     this._sql = void 0;
@@ -1955,11 +2077,14 @@ var _TinyCloudNode = class _TinyCloudNode {
     await this.tc.signIn(options);
     this.syncResolvedHostFromAuth();
     this.initializeServices();
+    const bootstrapped = await this.bootstrapAccountIfNeeded();
     await this.ensureRequestedEncryptionNetworks();
-    if (this.config.manifest === void 0 && this.config.capabilityRequest === void 0) {
-      await this.ensureOwnedSpaceHosted(this.ownedSpaceId("secrets"));
+    if (!bootstrapped && this.config.manifest === void 0 && this.config.capabilityRequest === void 0) {
+      await this.ensureOwnedSpaceHostedById(this.ownedSpaceId(import_sdk_core8.SECRETS_SPACE));
+    }
+    if (!bootstrapped) {
+      this.scheduleAccountRegistrySync();
     }
-    this.scheduleAccountRegistrySync();
     this.notificationHandler.success("Successfully signed in");
   }
   ownedSpaceId(name) {
@@ -1968,6 +2093,208 @@ var _TinyCloudNode = class _TinyCloudNode {
     }
     return this.wasmBindings.makeSpaceId(this._address, this._chainId, name);
   }
+  async bootstrapAccountIfNeeded() {
+    if (this.config.autoBootstrapAccount === false) {
+      return false;
+    }
+    if (!this.auth || !this._address) {
+      return false;
+    }
+    const steps = (0, import_sdk_core8.bootstrapSteps)(this._address, this._chainId);
+    if (!await this.isFreshBootstrapAccount(steps)) {
+      return false;
+    }
+    await this.runAccountBootstrap(steps);
+    return true;
+  }
+  async isFreshBootstrapAccount(steps) {
+    const enshrinedSpaceIds = /* @__PURE__ */ new Set();
+    for (const step of steps) {
+      if (step.kind === "session") {
+        enshrinedSpaceIds.add(step.spaceId);
+      }
+    }
+    const skipped = this.auth.lastActivationSkippedSpaceIds;
+    if (skipped.some((spaceId) => enshrinedSpaceIds.has(spaceId))) {
+      return true;
+    }
+    try {
+      const indexed = await this.account.index.spaces.list();
+      if (indexed.ok && indexed.data.length === 0) {
+        return true;
+      }
+    } catch {
+    }
+    try {
+      const spaces = await this.account.spaces.list();
+      return spaces.ok && spaces.data.length === 0;
+    } catch {
+      return false;
+    }
+  }
+  async runAccountBootstrap(steps) {
+    if (!this.auth || !this._address) {
+      throw new Error("Account bootstrap requires an active wallet session");
+    }
+    const host = this.hosts[0] ?? this.config.host;
+    if (!host) {
+      throw new Error("Account bootstrap requires a TinyCloud host");
+    }
+    const auth = this.auth;
+    const sessions = /* @__PURE__ */ new Map();
+    const rawAbilitiesBySpace = /* @__PURE__ */ new Map();
+    const primarySession = auth.tinyCloudSession;
+    const defaultSpaceId = this.ownedSpaceId("default");
+    const canReusePrimaryBootstrapSession = primarySession?.spaceId === defaultSpaceId && auth.capabilityRequest === import_sdk_core8.BOOTSTRAP_SESSION_REQUESTS.default;
+    for (const step of steps) {
+      if (step.kind !== "session") continue;
+      if (step.space === "default" && canReusePrimaryBootstrapSession && primarySession) {
+        sessions.set(step.space, primarySession);
+        continue;
+      }
+      const rawAbilities = step.rawAbilities;
+      if (rawAbilities) {
+        rawAbilitiesBySpace.set(step.space, rawAbilities);
+      }
+      const session = await auth.createBootstrapSession({
+        spaceId: step.spaceId,
+        capabilityRequest: step.request ?? import_sdk_core8.BOOTSTRAP_SESSION_REQUESTS[step.space],
+        rawAbilities
+      });
+      sessions.set(step.space, session);
+    }
+    for (const step of steps) {
+      if (step.kind !== "host") continue;
+      const hosted = await auth.hostOwnedSpace(step.spaceId);
+      if (!hosted) {
+        throw new Error(`Failed to host bootstrap space: ${step.spaceId}`);
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    for (const step of steps) {
+      if (step.kind !== "activate") continue;
+      const session = sessions.get(step.space);
+      if (!session) {
+        throw new Error(`Missing bootstrap session for ${step.space}`);
+      }
+      const activated = await (0, import_sdk_core8.activateSessionWithHost)(host, session.delegationHeader);
+      if (!activated.success || activated.skipped?.includes(step.spaceId)) {
+        throw new Error(
+          `Failed to activate bootstrap session for ${step.spaceId}: ${activated.error ?? "space was skipped"}`
+        );
+      }
+      this.registerBootstrapRuntimeGrant(
+        session,
+        import_sdk_core8.BOOTSTRAP_SESSION_REQUESTS[step.space],
+        rawAbilitiesBySpace.get(step.space)
+      );
+    }
+    for (const step of steps) {
+      if (step.kind === "account-index-schema") {
+        const ensured = await this.account.index.ensure();
+        if (!ensured.ok) {
+          throw new Error(`Failed to create account index schema: ${ensured.error.message}`);
+        }
+      }
+      if (step.kind === "seed-spaces") {
+        for (const space of step.spaces) {
+          const registered = await this.account.spaces.register({
+            spaceId: space.spaceId,
+            name: space.name,
+            ownerDid: this.did,
+            type: "owned",
+            permissions: ["*"],
+            status: "active"
+          });
+          if (!registered.ok) {
+            throw new Error(
+              `Failed to seed account space ${space.spaceId}: ${registered.error.message}`
+            );
+          }
+        }
+      }
+      if (step.kind === "seed-applications") {
+        const registered = await this.account.applications.register(
+          step.manifests.length > 0 ? [...step.manifests] : import_sdk_core8.TINYCLOUD_SECRETS_BOOTSTRAP_MANIFEST
+        );
+        if (!registered.ok) {
+          throw new Error(`Failed to seed bootstrap applications: ${registered.error.message}`);
+        }
+      }
+      if (step.kind === "encryption-network-create") {
+        await this.ensureEncryptionNetwork(step.networkId);
+      }
+      if (step.kind === "secret-records-schema") {
+        const db = this.sqlForSpace(step.spaceId).db(step.database);
+        const migrated = await db.migrations.apply({
+          namespace: "tinycloud.secrets.records",
+          migrations: [
+            {
+              id: "001_initial",
+              sql: [...import_sdk_core8.SECRET_RECORDS_SCHEMA]
+            }
+          ]
+        });
+        if (!migrated.ok) {
+          throw new Error(
+            `Failed to create secret_records schema: ${migrated.error.message}`
+          );
+        }
+      }
+    }
+  }
+  registerBootstrapRuntimeGrant(session, request, rawAbilities) {
+    const operations = [];
+    for (const resource of request.resources) {
+      const service = resource.service.startsWith("tinycloud.") ? this.shortServiceName(resource.service) : resource.service;
+      const spaceId = resource.space.startsWith("tinycloud:") ? resource.space : this.ownedSpaceId(resource.space);
+      for (const action of resource.actions) {
+        operations.push({
+          spaceId,
+          service,
+          path: resource.path,
+          action
+        });
+      }
+    }
+    for (const [resource, actions2] of Object.entries(rawAbilities ?? {})) {
+      for (const action of actions2) {
+        operations.push({
+          resource,
+          service: "encryption",
+          path: resource,
+          action
+        });
+      }
+    }
+    const expiresAt = extractSiweExpiration(session.siwe) ?? this.getSessionExpiry();
+    const actions = [...new Set(operations.map((operation) => operation.action))];
+    this.runtimePermissionGrants.push({
+      session: {
+        delegationHeader: session.delegationHeader,
+        delegationCid: session.delegationCid,
+        spaceId: session.spaceId,
+        verificationMethod: session.verificationMethod,
+        jwk: session.jwk
+      },
+      delegation: {
+        cid: session.delegationCid,
+        delegationHeader: session.delegationHeader,
+        delegateDID: session.verificationMethod,
+        delegatorDID: this.did,
+        spaceId: session.spaceId,
+        path: "",
+        actions,
+        expiry: expiresAt,
+        allowSubDelegation: true,
+        ownerAddress: session.address,
+        chainId: session.chainId,
+        host: this.config.host
+      },
+      operations,
+      expiresAt
+    });
+  }
   async writeManifestRegistryRecords() {
     const request = this.capabilityRequest;
     if (!request || request.registryRecords.length === 0) {
@@ -1976,8 +2303,8 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!this.auth || !this.signer) {
       throw new Error("Manifest registry write requires wallet mode");
     }
-    const accountSpaceId = this.ownedSpaceId(import_sdk_core7.ACCOUNT_REGISTRY_SPACE);
-    await this.ensureOwnedSpaceHosted(accountSpaceId);
+    const accountSpaceId = this.ownedSpaceId(import_sdk_core8.ACCOUNT_REGISTRY_SPACE);
+    await this.ensureOwnedSpaceHostedById(accountSpaceId);
     const result = await this.account.applications.register(request.manifests);
     if (!result.ok) {
       throw new Error(
@@ -1987,6 +2314,7 @@ var _TinyCloudNode = class _TinyCloudNode {
   }
   scheduleAccountRegistrySync() {
     void this.withAccountRegistryRetry(async () => {
+      void this.account.index.ensure();
       await this.writeManifestRegistryRecords();
       const spaces = await this.account.spaces.syncAccessible();
       if (!spaces.ok) {
@@ -2020,7 +2348,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     }
     const networkIds = /* @__PURE__ */ new Set();
     for (const resource of request.resources) {
-      if (resource.service === import_sdk_core7.ENCRYPTION_PERMISSION_SERVICE && resource.path.startsWith("urn:tinycloud:encryption:") && resource.actions.includes(DECRYPT_ACTION2)) {
+      if (resource.service === import_sdk_core8.ENCRYPTION_PERMISSION_SERVICE && resource.path.startsWith("urn:tinycloud:encryption:") && resource.actions.includes(DECRYPT_ACTION2)) {
         networkIds.add(resource.path);
       }
     }
@@ -2031,14 +2359,14 @@ var _TinyCloudNode = class _TinyCloudNode {
       return;
     }
     for (const networkId of this.requestedEncryptionNetworkIds()) {
-      const parsed = (0, import_sdk_core7.parseNetworkId)(networkId);
+      const parsed = (0, import_sdk_core8.parseNetworkId)(networkId);
       if (!didPrincipalMatches2(parsed.ownerDid, this.did)) {
         continue;
       }
       await this.ensureEncryptionNetwork(networkId);
     }
   }
-  async ensureOwnedSpaceHosted(spaceId) {
+  async ensureOwnedSpaceHostedById(spaceId) {
     if (!this.auth) {
       throw new Error("Owned space hosting requires wallet mode");
     }
@@ -2050,7 +2378,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!host) {
       throw new Error("Owned space hosting requires a TinyCloud host");
     }
-    const activation = await (0, import_sdk_core7.activateSessionWithHost)(host, session.delegationHeader);
+    const activation = await (0, import_sdk_core8.activateSessionWithHost)(host, session.delegationHeader);
     if (activation.success && !activation.skipped?.includes(spaceId)) {
       return;
     }
@@ -2064,7 +2392,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       throw new Error(`Failed to create owned space: ${spaceId}`);
     }
     await new Promise((resolve) => setTimeout(resolve, 100));
-    const retry = await (0, import_sdk_core7.activateSessionWithHost)(host, session.delegationHeader);
+    const retry = await (0, import_sdk_core8.activateSessionWithHost)(host, session.delegationHeader);
     if (!retry.success || retry.skipped?.includes(spaceId)) {
       throw new Error(
         `Failed to activate session after creating owned space ${spaceId}: ${retry.error ?? "space was skipped"}`
@@ -2081,7 +2409,7 @@ var _TinyCloudNode = class _TinyCloudNode {
    * caller is the root authority of their own owned spaces, so no additional
    * delegation is required.
    *
-   * Unlike {@link ensureOwnedSpaceHosted}, this always submits the host
+   * Unlike {@link ensureOwnedSpaceHostedById}, this always submits the host
    * delegation rather than inferring hosting from session activation: a space
    * the current session has never referenced is reported neither as
    * `activated` nor `skipped`, so activation-based detection would wrongly
@@ -2106,7 +2434,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!hosted) {
       throw new Error(`Failed to host owned space: ${spaceId}`);
     }
-    const activation = await (0, import_sdk_core7.activateSessionWithHost)(
+    const activation = await (0, import_sdk_core8.activateSessionWithHost)(
       host,
       this.auth.tinyCloudSession.delegationHeader
     );
@@ -2126,6 +2454,91 @@ var _TinyCloudNode = class _TinyCloudNode {
     });
     return spaceId;
   }
+  /**
+   * Ensure one of this user's owned spaces (e.g. `"secrets"`) is hosted on the
+   * server.
+   *
+   * At sign-in, a full-authority session auto-hosts the owner's `secrets`
+   * space, but a session created with a manifest / capabilityRequest does not.
+   * Such a session can therefore hold valid `tinycloud.kv/*` capabilities for
+   * the owned `secrets` space yet still fail its first scoped
+   * `secrets.put(...)` with `404 Space not found`, because the space was never
+   * registered on the node.
+   *
+   * Calling this resolves `name` to the owner's owned-space URI
+   * (`tinycloud:pkh:eip155:<chain>:<addr>:<name>`). It first consults the
+   * account-space spaces registry (`account/spaces/{space_id}`, the canonical
+   * KV source of truth, fronted by a best-effort SQLite index): if the space is
+   * already registered/hosted it returns the URI WITHOUT submitting a host
+   * delegation, avoiding a redundant host-SIWE signature prompt for owners who
+   * already use the space. Only when the space is absent — or the registry
+   * check fails for any reason (e.g. a cold SQLite index reporting
+   * `no such table: spaces`) — does it fall through to {@link hostOwnedSpace}.
+   *
+   * The registry check is purely an optimization: any failure falls back to
+   * hosting, and the host SIWE is idempotent server-side, so re-hosting an
+   * existing space remains a safe no-op. Must be called after {@link signIn}.
+   *
+   * @param name - The owned space name (e.g. `"secrets"`).
+   * @returns The hosted owned-space URI.
+   */
+  async ensureOwnedSpaceHosted(name) {
+    if (!this.auth || !this.auth.tinyCloudSession) {
+      throw new Error("Not signed in. Call signIn() first.");
+    }
+    const spaceId = this.ownedSpaceId(name);
+    if (await this.isOwnedSpaceRegistered(spaceId)) {
+      return spaceId;
+    }
+    const hosted = await this.hostOwnedSpace(name);
+    try {
+      await this.account.spaces.register({
+        spaceId,
+        name,
+        ownerDid: this.did,
+        type: "owned",
+        permissions: ["*"],
+        status: "active"
+      });
+    } catch {
+    }
+    return hosted;
+  }
+  /**
+   * Check whether an owned space is already registered/hosted by consulting the
+   * account spaces registry.
+   *
+   * Source of truth is the canonical KV registry record
+   * `account/spaces/{space_id}`, read here via `account.spaces.get(spaceId)`.
+   * The KV path is used (rather than `syncAccessible()`) because it works under
+   * a manifest/recap session with NO extra prompt: the composed manifest recap
+   * already grants `tinycloud.kv get/list` on the account space `spaces/`
+   * prefix, whereas `syncAccessible()` depends on `tinycloud.space/list`, which
+   * a recap session does not hold. Before reading, it consults the fast SQLite
+   * index (`account.index.spaces.list()`) as a best-effort short-circuit; on a
+   * cold index (`no such table: spaces`) or any other index failure it falls
+   * back to the canonical KV read.
+   *
+   * This is a best-effort optimization. ANY failure of the check path (missing
+   * table, KV error, missing record, thrown exception) resolves to `false` so
+   * the caller falls through to hosting — per the directive, "if it fails in any
+   * way then create the space".
+   */
+  async isOwnedSpaceRegistered(spaceId) {
+    try {
+      const indexed = await this.account.index.spaces.list();
+      if (indexed.ok && indexed.data.some((space) => space.spaceId === spaceId)) {
+        return true;
+      }
+    } catch {
+    }
+    try {
+      const record = await this.account.spaces.get(spaceId);
+      return record.ok;
+    } catch {
+      return false;
+    }
+  }
   /**
    * Restore a previously established session from stored delegation data.
    *
@@ -2148,30 +2561,38 @@ var _TinyCloudNode = class _TinyCloudNode {
     this._spaceService = void 0;
     this._serviceContext = void 0;
     this.runtimePermissionGrants = [];
-    const restoredAddress = sessionData.address ? (0, import_sdk_core7.canonicalizeAddress)(sessionData.address) : void 0;
+    const restoredAddress = sessionData.address ? (0, import_sdk_core8.canonicalizeAddress)(sessionData.address) : void 0;
     if (restoredAddress) {
       this._address = restoredAddress;
     }
     if (sessionData.chainId) {
       this._chainId = sessionData.chainId;
     }
-    this._serviceContext = new import_sdk_core7.ServiceContext({
+    const resolvedHost = await this.resolveRestoredHost(
+      sessionData.tinycloudHosts,
+      restoredAddress,
+      sessionData.chainId
+    );
+    if (resolvedHost) {
+      this.config.host = resolvedHost;
+    }
+    this._serviceContext = new import_sdk_core8.ServiceContext({
       invoke: this.invokeWithRuntimePermissions,
       invokeAny: this.invokeAnyWithRuntimePermissions,
       fetch: globalThis.fetch.bind(globalThis),
       hosts: [this.config.host],
       telemetry: this.config.telemetry
     });
-    this._kv = new import_sdk_core7.KVService({});
+    this._kv = new import_sdk_core8.KVService({});
     this._kv.initialize(this._serviceContext);
     this._serviceContext.registerService("kv", this._kv);
-    this._sql = new import_sdk_core7.SQLService({});
+    this._sql = new import_sdk_core8.SQLService({});
     this._sql.initialize(this._serviceContext);
     this._serviceContext.registerService("sql", this._sql);
-    this._duckdb = new import_sdk_core7.DuckDbService({});
+    this._duckdb = new import_sdk_core8.DuckDbService({});
     this._duckdb.initialize(this._serviceContext);
     this._serviceContext.registerService("duckdb", this._duckdb);
-    this._hooks = new import_sdk_core7.HooksService({});
+    this._hooks = new import_sdk_core8.HooksService({});
     this._hooks.initialize(this._serviceContext);
     this._serviceContext.registerService("hooks", this._hooks);
     const serviceSession = {
@@ -2200,12 +2621,45 @@ var _TinyCloudNode = class _TinyCloudNode {
         signature: sessionData.signature ?? ""
       };
       if (this.auth) {
-        this.auth.setRestoredTinyCloudSession(tcSession);
+        this.auth.setRestoredTinyCloudSession(
+          tcSession,
+          this.config.host ? [this.config.host] : void 0
+        );
       } else {
         this._restoredTcSession = tcSession;
       }
     }
   }
+  /**
+   * Resolve the host a restored session should target.
+   *
+   * Mirrors fresh sign-in host resolution but for the restore path:
+   * an explicit/pinned host always wins, then the hosts the session was
+   * persisted with, then a lazy registry/fallback resolution for sessions
+   * that predate the persisted `tinycloudHosts` field. Returns `undefined`
+   * only when there's nothing to resolve from (no explicit host, no
+   * persisted hosts, and no address/chainId) — in which case the existing
+   * `config.host` (default) is left in place.
+   *
+   * Resolution failures are surfaced, not swallowed: a genuinely broken
+   * registry lookup throws rather than silently falling back to a wrong host.
+   */
+  async resolveRestoredHost(persistedHosts, address, chainId) {
+    if (this.explicitHost) {
+      return this.explicitHost;
+    }
+    if (persistedHosts && persistedHosts.length > 0) {
+      return persistedHosts[0];
+    }
+    if (address === void 0 || chainId === void 0) {
+      return void 0;
+    }
+    const resolved = await (0, import_sdk_core8.resolveTinyCloudHosts)((0, import_sdk_core8.pkhDid)(address, chainId), {
+      registryUrl: this.config.tinycloudRegistryUrl,
+      fallbackHosts: this.config.tinycloudFallbackHosts
+    });
+    return resolved.hosts[0];
+  }
   /**
    * Resolve the currently-active TinyCloudSession, preferring the auth
    * layer's value (wallet mode) and falling back to the node-level
@@ -2250,9 +2704,11 @@ var _TinyCloudNode = class _TinyCloudNode {
       );
     }
     this.signer = _TinyCloudNode.nodeDefaults.createSigner(privateKey);
+    const authConfig = { ...this.config, prefix };
+    const useBootstrapSignInRequest = this.shouldUseBootstrapSignInRequest(authConfig);
     this.auth = new NodeUserAuthorization({
       signer: this.signer,
-      signStrategy: { type: "auto-sign" },
+      signStrategy: this.config.signStrategy ?? { type: "auto-sign" },
       wasmBindings: this.wasmBindings,
       sessionStorage: options?.sessionStorage ?? this.config.sessionStorage ?? new MemorySessionStorage(),
       domain: this.siweDomain,
@@ -2261,16 +2717,16 @@ var _TinyCloudNode = class _TinyCloudNode {
       tinycloudHosts: this.explicitHost ? [this.explicitHost] : void 0,
       tinycloudRegistryUrl: this.config.tinycloudRegistryUrl,
       tinycloudFallbackHosts: this.config.tinycloudFallbackHosts,
-      autoCreateSpace: this.config.autoCreateSpace,
+      autoCreateSpace: useBootstrapSignInRequest ? false : this.config.autoCreateSpace,
       enablePublicSpace: this.config.enablePublicSpace ?? true,
-      spaceCreationHandler: this.config.spaceCreationHandler,
+      spaceCreationHandler: useBootstrapSignInRequest ? void 0 : this.config.spaceCreationHandler,
       nonce: this.config.nonce,
       siweConfig: this.config.siweConfig,
-      manifest: this.config.manifest,
-      capabilityRequest: this.config.capabilityRequest,
-      includeAccountRegistryPermissions: this.config.includeAccountRegistryPermissions
+      manifest: useBootstrapSignInRequest ? void 0 : this.config.manifest,
+      capabilityRequest: useBootstrapSignInRequest ? import_sdk_core8.BOOTSTRAP_SESSION_REQUESTS.default : this.config.capabilityRequest,
+      includeAccountRegistryPermissions: useBootstrapSignInRequest ? false : this.config.includeAccountRegistryPermissions
     });
-    this.tc = new import_sdk_core7.TinyCloud(this.auth, {
+    this.tc = new import_sdk_core8.TinyCloud(this.auth, {
       invokeAny: this.invokeAnyWithRuntimePermissions,
       telemetry: this.config.telemetry
     });
@@ -2295,9 +2751,11 @@ var _TinyCloudNode = class _TinyCloudNode {
     }
     const prefix = options?.prefix ?? "default";
     this.signer = signer;
+    const authConfig = { ...this.config, prefix };
+    const useBootstrapSignInRequest = this.shouldUseBootstrapSignInRequest(authConfig);
     this.auth = new NodeUserAuthorization({
       signer: this.signer,
-      signStrategy: { type: "auto-sign" },
+      signStrategy: this.config.signStrategy ?? { type: "auto-sign" },
       wasmBindings: this.wasmBindings,
       sessionStorage: options?.sessionStorage ?? this.config.sessionStorage ?? new MemorySessionStorage(),
       domain: this.siweDomain,
@@ -2306,16 +2764,16 @@ var _TinyCloudNode = class _TinyCloudNode {
       tinycloudHosts: this.explicitHost ? [this.explicitHost] : void 0,
       tinycloudRegistryUrl: this.config.tinycloudRegistryUrl,
       tinycloudFallbackHosts: this.config.tinycloudFallbackHosts,
-      autoCreateSpace: this.config.autoCreateSpace,
+      autoCreateSpace: useBootstrapSignInRequest ? false : this.config.autoCreateSpace,
       enablePublicSpace: this.config.enablePublicSpace ?? true,
-      spaceCreationHandler: this.config.spaceCreationHandler,
+      spaceCreationHandler: useBootstrapSignInRequest ? void 0 : this.config.spaceCreationHandler,
       nonce: this.config.nonce,
       siweConfig: this.config.siweConfig,
-      manifest: this.config.manifest,
-      capabilityRequest: this.config.capabilityRequest,
-      includeAccountRegistryPermissions: this.config.includeAccountRegistryPermissions
+      manifest: useBootstrapSignInRequest ? void 0 : this.config.manifest,
+      capabilityRequest: useBootstrapSignInRequest ? import_sdk_core8.BOOTSTRAP_SESSION_REQUESTS.default : this.config.capabilityRequest,
+      includeAccountRegistryPermissions: useBootstrapSignInRequest ? false : this.config.includeAccountRegistryPermissions
     });
-    this.tc = new import_sdk_core7.TinyCloud(this.auth, {
+    this.tc = new import_sdk_core8.TinyCloud(this.auth, {
       invokeAny: this.invokeAnyWithRuntimePermissions,
       telemetry: this.config.telemetry
     });
@@ -2331,28 +2789,28 @@ var _TinyCloudNode = class _TinyCloudNode {
       return;
     }
     this.tc.initializeServices(this.invokeWithRuntimePermissions, [this.config.host]);
-    this._serviceContext = new import_sdk_core7.ServiceContext({
+    this._serviceContext = new import_sdk_core8.ServiceContext({
       invoke: this.invokeWithRuntimePermissions,
       invokeAny: this.invokeAnyWithRuntimePermissions,
       fetch: globalThis.fetch.bind(globalThis),
       hosts: [this.config.host],
       telemetry: this.config.telemetry
     });
-    this._kv = new import_sdk_core7.KVService({});
+    this._kv = new import_sdk_core8.KVService({});
     this._kv.initialize(this._serviceContext);
     this._serviceContext.registerService("kv", this._kv);
     const features = this.nodeFeatures;
     if (features.length === 0 || features.includes("sql")) {
-      this._sql = new import_sdk_core7.SQLService({});
+      this._sql = new import_sdk_core8.SQLService({});
       this._sql.initialize(this._serviceContext);
       this._serviceContext.registerService("sql", this._sql);
     }
     if (features.length === 0 || features.includes("duckdb")) {
-      this._duckdb = new import_sdk_core7.DuckDbService({});
+      this._duckdb = new import_sdk_core8.DuckDbService({});
       this._duckdb.initialize(this._serviceContext);
       this._serviceContext.registerService("duckdb", this._duckdb);
     }
-    this._hooks = new import_sdk_core7.HooksService({});
+    this._hooks = new import_sdk_core8.HooksService({});
     this._hooks.initialize(this._serviceContext);
     this._serviceContext.registerService("hooks", this._hooks);
     const serviceSession = {
@@ -2370,9 +2828,9 @@ var _TinyCloudNode = class _TinyCloudNode {
     this.initializeV2Services(serviceSession);
   }
   createSpaceScopedKVService(spaceId) {
-    const kvService = new import_sdk_core7.KVService({});
+    const kvService = new import_sdk_core8.KVService({});
     if (this._serviceContext) {
-      const spaceScopedContext = new import_sdk_core7.ServiceContext({
+      const spaceScopedContext = new import_sdk_core8.ServiceContext({
         invoke: this._serviceContext.invoke,
         fetch: this._serviceContext.fetch,
         hosts: this._serviceContext.hosts,
@@ -2437,7 +2895,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         const shared = wasm.vault_x25519_dh(receiverPrivateKey, peerPublic);
         return columnDecrypt(shared, ciphertext);
       },
-      verifyNodeSignature: (nodeId, message, signature) => (0, import_sdk_core7.verifyDidKeyEd25519Signature)(nodeId, message, signature)
+      verifyNodeSignature: (nodeId, message, signature) => (0, import_sdk_core8.verifyDidKeyEd25519Signature)(nodeId, message, signature)
     };
   }
   async fetchNodeId() {
@@ -2508,7 +2966,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         return await response.json();
       }
     };
-    return new import_sdk_core7.EncryptionService({
+    return new import_sdk_core8.EncryptionService({
       crypto,
       signer: {
         signDecryptInvocation: async (input) => {
@@ -2520,7 +2978,7 @@ var _TinyCloudNode = class _TinyCloudNode {
           });
           return {
             ...signed,
-            canonicalBody: (0, import_sdk_core7.canonicalizeEncryptionJson)(
+            canonicalBody: (0, import_sdk_core8.canonicalizeEncryptionJson)(
               input.body
             )
           };
@@ -2538,8 +2996,8 @@ var _TinyCloudNode = class _TinyCloudNode {
           if (!this.config.host) {
             return null;
           }
-          const publicSpaceId = (0, import_sdk_core7.makePublicSpaceId)(this._address, this._chainId);
-          const result = await import_sdk_core7.TinyCloud.readPublicSpace(this.config.host, publicSpaceId, discoveryKey);
+          const publicSpaceId = (0, import_sdk_core8.makePublicSpaceId)(this._address, this._chainId);
+          const result = await import_sdk_core8.TinyCloud.readPublicSpace(this.config.host, publicSpaceId, discoveryKey);
           if (!result.ok) {
             return null;
           }
@@ -2562,7 +3020,7 @@ var _TinyCloudNode = class _TinyCloudNode {
   }
   createVaultService(spaceId, kv) {
     const wasm = this.wasmBindings;
-    const vaultCrypto = (0, import_sdk_core7.createVaultCrypto)({
+    const vaultCrypto = (0, import_sdk_core8.createVaultCrypto)({
       vault_encrypt: wasm.vault_encrypt,
       vault_decrypt: wasm.vault_decrypt,
       vault_derive_key: wasm.vault_derive_key,
@@ -2572,7 +3030,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       vault_sha256: wasm.vault_sha256
     });
     const self = this;
-    return new import_sdk_core7.DataVaultService({
+    return new import_sdk_core8.DataVaultService({
       spaceId,
       crypto: vaultCrypto,
       encryption: {
@@ -2595,8 +3053,8 @@ var _TinyCloudNode = class _TinyCloudNode {
         get publicKV() {
           return self._publicKV ?? self.tc.publicKV;
         },
-        readPublicSpace: (host, targetSpaceId, key) => import_sdk_core7.TinyCloud.readPublicSpace(host, targetSpaceId, key),
-        makePublicSpaceId: import_sdk_core7.TinyCloud.makePublicSpaceId,
+        readPublicSpace: (host, targetSpaceId, key) => import_sdk_core8.TinyCloud.readPublicSpace(host, targetSpaceId, key),
+        makePublicSpaceId: import_sdk_core8.TinyCloud.makePublicSpaceId,
         did: this.did,
         address: this._address ?? "",
         chainId: this._chainId,
@@ -2609,7 +3067,7 @@ var _TinyCloudNode = class _TinyCloudNode {
    * @internal
    */
   initializeV2Services(serviceSession) {
-    this._capabilityRegistry = new import_sdk_core7.CapabilityKeyRegistry();
+    this._capabilityRegistry = new import_sdk_core8.CapabilityKeyRegistry();
     const tcSession = this.auth?.tinyCloudSession;
     if (tcSession && this._address) {
       const sessionKey = {
@@ -2683,13 +3141,13 @@ var _TinyCloudNode = class _TinyCloudNode {
       }
       this._capabilityRegistry.registerKey(sessionKey, delegations);
     }
-    this._delegationManager = new import_sdk_core7.DelegationManager({
+    this._delegationManager = new import_sdk_core8.DelegationManager({
       hosts: [this.config.host],
       session: serviceSession,
       invoke: this.invokeWithRuntimePermissions,
       fetch: globalThis.fetch.bind(globalThis)
     });
-    this._spaceService = new import_sdk_core7.SpaceService({
+    this._spaceService = new import_sdk_core8.SpaceService({
       hosts: [this.config.host],
       session: serviceSession,
       invoke: this.wasmBindings.invoke,
@@ -2849,7 +3307,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         ...prepared,
         signature
       });
-      const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
+      const activateResult = await (0, import_sdk_core8.activateSessionWithHost)(
         host,
         delegationSession.delegationHeader
       );
@@ -2859,7 +3317,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       return {
         cid: delegationSession.delegationCid,
         delegateDID: params.shareKeyDID,
-        delegatorDID: (0, import_sdk_core7.pkhDid)(session.address, session.chainId),
+        delegatorDID: (0, import_sdk_core8.pkhDid)(session.address, session.chainId),
         spaceId: params.spaceId,
         path: params.path,
         actions: params.actions,
@@ -2916,7 +3374,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!this._sql) {
       const features = this.nodeFeatures;
       if (features.length > 0 && !features.includes("sql")) {
-        throw new import_sdk_core7.UnsupportedFeatureError("sql", this.config.host, features);
+        throw new import_sdk_core8.UnsupportedFeatureError("sql", this.config.host, features);
       }
       throw new Error("Not signed in. Call signIn() first.");
     }
@@ -2940,8 +3398,8 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!this._serviceContext || !this._serviceContext.session) {
       throw new Error("Not signed in. Call signIn() first.");
     }
-    const sql = new import_sdk_core7.SQLService({});
-    const spaceScopedContext = new import_sdk_core7.ServiceContext({
+    const sql = new import_sdk_core8.SQLService({});
+    const spaceScopedContext = new import_sdk_core8.ServiceContext({
       invoke: this._serviceContext.invoke,
       fetch: this._serviceContext.fetch,
       hosts: this._serviceContext.hosts,
@@ -2969,8 +3427,8 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!this._serviceContext || !this._serviceContext.session) {
       throw new Error("Not signed in. Call signIn() first.");
     }
-    const kv = new import_sdk_core7.KVService({});
-    const spaceScopedContext = new import_sdk_core7.ServiceContext({
+    const kv = new import_sdk_core8.KVService({});
+    const spaceScopedContext = new import_sdk_core8.ServiceContext({
       invoke: this._serviceContext.invoke,
       fetch: this._serviceContext.fetch,
       hosts: this._serviceContext.hosts
@@ -2986,7 +3444,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!this._duckdb) {
       const features = this.nodeFeatures;
       if (features.length > 0 && !features.includes("duckdb")) {
-        throw new import_sdk_core7.UnsupportedFeatureError("duckdb", this.config.host, features);
+        throw new import_sdk_core8.UnsupportedFeatureError("duckdb", this.config.host, features);
       }
       throw new Error("Not signed in. Call signIn() first.");
     }
@@ -3038,7 +3496,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       type: NETWORK_ADMIN_TYPE,
       targetNode,
       networkId,
-      bodyHash: (0, import_sdk_core7.canonicalHashHex)(
+      bodyHash: (0, import_sdk_core8.canonicalHashHex)(
         crypto.sha256,
         body
       ),
@@ -3056,7 +3514,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         Authorization: signed.authorization,
         "Content-Type": "application/json"
       },
-      body: (0, import_sdk_core7.canonicalizeEncryptionJson)(
+      body: (0, import_sdk_core8.canonicalizeEncryptionJson)(
         body
       )
     });
@@ -3074,7 +3532,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (existing) {
       return existing;
     }
-    const parsed = (0, import_sdk_core7.parseNetworkId)(networkId);
+    const parsed = (0, import_sdk_core8.parseNetworkId)(networkId);
     if (!didPrincipalMatches2(parsed.ownerDid, this.did)) {
       throw new Error(
         `Cannot create encryption network ${networkId}: owner ${parsed.ownerDid} does not match signed-in DID ${this.did}`
@@ -3107,7 +3565,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       throw new Error("Not signed in. Call signIn() first.");
     }
     if (!this._baseSecrets) {
-      this._baseSecrets = new import_sdk_core7.SecretsService(() => this.space("secrets").vault);
+      this._baseSecrets = new import_sdk_core8.SecretsService(() => this.space("secrets").vault);
     }
     return this._baseSecrets;
   }
@@ -3222,10 +3680,10 @@ var _TinyCloudNode = class _TinyCloudNode {
   async useRuntimeDelegation(delegation) {
     const session = this.currentTinyCloudSession();
     if (!session) {
-      throw new import_sdk_core7.SessionExpiredError(/* @__PURE__ */ new Date(0));
+      throw new import_sdk_core8.SessionExpiredError(/* @__PURE__ */ new Date(0));
     }
     if (delegation.expiry.getTime() <= Date.now()) {
-      throw new import_sdk_core7.SessionExpiredError(delegation.expiry);
+      throw new import_sdk_core8.SessionExpiredError(delegation.expiry);
     }
     const expectedDids = [session.verificationMethod, this.sessionDid];
     if (!expectedDids.some((did) => didPrincipalMatches2(delegation.delegateDID, did))) {
@@ -3234,7 +3692,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       );
     }
     const targetHost = delegation.host ?? this.config.host;
-    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core8.activateSessionWithHost)(
       targetHost,
       delegation.delegationHeader
     );
@@ -3261,13 +3719,13 @@ var _TinyCloudNode = class _TinyCloudNode {
     }
     const session = this.currentTinyCloudSession();
     if (!session) {
-      throw new import_sdk_core7.SessionExpiredError(/* @__PURE__ */ new Date(0));
+      throw new import_sdk_core8.SessionExpiredError(/* @__PURE__ */ new Date(0));
     }
     const sessionExpiry = extractSiweExpiration(session.siwe);
     if (sessionExpiry !== void 0) {
       const marginMs = _TinyCloudNode.SESSION_EXPIRY_SAFETY_MARGIN_MS;
       if (sessionExpiry.getTime() <= Date.now() + marginMs) {
-        throw new import_sdk_core7.SessionExpiredError(sessionExpiry);
+        throw new import_sdk_core8.SessionExpiredError(sessionExpiry);
       }
     }
     const expanded = this.expandPermissionEntries(permissions);
@@ -3330,7 +3788,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         ...prepared,
         signature
       });
-      const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
+      const activateResult = await (0, import_sdk_core8.activateSessionWithHost)(
         this.config.host,
         delegatedSession.delegationHeader
       );
@@ -3503,7 +3961,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     ];
     const abilities = { kv: { "": kvActions } };
     const now = /* @__PURE__ */ new Date();
-    const expiryMs = import_sdk_core7.EXPIRY.EPHEMERAL_MS;
+    const expiryMs = import_sdk_core8.EXPIRY.EPHEMERAL_MS;
     const expirationTime = new Date(now.getTime() + expiryMs);
     const prepared = this.wasmBindings.prepareSession({
       abilities,
@@ -3521,7 +3979,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       ...prepared,
       signature
     });
-    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core8.activateSessionWithHost)(
       this.config.host,
       delegationSession.delegationHeader
     );
@@ -3548,8 +4006,8 @@ var _TinyCloudNode = class _TinyCloudNode {
       }]);
     }
     if (this._serviceContext) {
-      const publicKV = new import_sdk_core7.KVService({ prefix: "" });
-      const publicContext = new import_sdk_core7.ServiceContext({
+      const publicKV = new import_sdk_core8.KVService({ prefix: "" });
+      const publicContext = new import_sdk_core8.ServiceContext({
         invoke: this.invokeWithRuntimePermissions,
         fetch: this._serviceContext.fetch,
         hosts: this._serviceContext.hosts,
@@ -3676,14 +4134,14 @@ var _TinyCloudNode = class _TinyCloudNode {
   async delegateTo(did, permissions, options) {
     const session = this.currentTinyCloudSession();
     if (!session) {
-      throw new import_sdk_core7.SessionExpiredError(/* @__PURE__ */ new Date(0));
+      throw new import_sdk_core8.SessionExpiredError(/* @__PURE__ */ new Date(0));
     }
     const sessionExpiry = extractSiweExpiration(session.siwe);
     if (sessionExpiry !== void 0) {
       const now2 = Date.now();
       const marginMs = _TinyCloudNode.SESSION_EXPIRY_SAFETY_MARGIN_MS;
       if (sessionExpiry.getTime() <= now2 + marginMs) {
-        throw new import_sdk_core7.SessionExpiredError(sessionExpiry);
+        throw new import_sdk_core8.SessionExpiredError(sessionExpiry);
       }
     }
     if (!Array.isArray(permissions) || permissions.length === 0) {
@@ -3712,11 +4170,11 @@ var _TinyCloudNode = class _TinyCloudNode {
       );
       return { delegation: delegation2, prompted: true };
     }
-    const granted = (0, import_sdk_core7.parseRecapCapabilities)(
+    const granted = (0, import_sdk_core8.parseRecapCapabilities)(
       (siwe) => this.wasmBindings.parseRecapFromSiwe(siwe),
       session.siwe
     );
-    const { subset, missing } = (0, import_sdk_core7.isCapabilitySubset)(expandedEntries, granted);
+    const { subset, missing } = (0, import_sdk_core8.isCapabilitySubset)(expandedEntries, granted);
     if (!subset) {
       const runtimeGrant = this.findGrantForOperations(
         this.permissionEntriesToOperations(expandedEntries, session)
@@ -3724,7 +4182,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       if (runtimeGrant) {
         const marginMs = _TinyCloudNode.SESSION_EXPIRY_SAFETY_MARGIN_MS;
         if (runtimeGrant.expiresAt.getTime() <= Date.now() + marginMs) {
-          throw new import_sdk_core7.SessionExpiredError(runtimeGrant.expiresAt);
+          throw new import_sdk_core8.SessionExpiredError(runtimeGrant.expiresAt);
         }
         const runtimeExpiration = runtimeGrant.expiresAt < effectiveExpiration ? runtimeGrant.expiresAt : effectiveExpiration;
         const delegation2 = await this.createDelegationViaRuntimeGrant(
@@ -3735,7 +4193,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         );
         return { delegation: delegation2, prompted: false };
       }
-      throw new import_sdk_core7.PermissionNotInManifestError(missing, granted);
+      throw new import_sdk_core8.PermissionNotInManifestError(missing, granted);
     }
     const delegation = await this.createDelegationViaWasmPath(
       did,
@@ -3817,7 +4275,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     const spaceId = resolvedSpaces.size === 1 ? [...resolvedSpaces][0] : session.spaceId;
     const abilities = {};
     for (const entry of entries) {
-      const shortService = import_sdk_core7.SERVICE_LONG_TO_SHORT[entry.service];
+      const shortService = import_sdk_core8.SERVICE_LONG_TO_SHORT[entry.service];
       if (shortService === void 0) {
         throw new Error(
           `delegateTo: unknown service '${entry.service}' \u2014 no short-form mapping`
@@ -3857,7 +4315,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     });
     const primary = result.resources[0];
     const delegationHeader = { Authorization: result.delegation };
-    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core8.activateSessionWithHost)(
       this.config.host,
       delegationHeader
     );
@@ -3892,7 +4350,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     const primary = result.resources[0];
     const delegationHeader = { Authorization: result.delegation };
     const targetHost = grant.delegation.host ?? this.config.host;
-    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core8.activateSessionWithHost)(
       targetHost,
       delegationHeader
     );
@@ -3933,10 +4391,10 @@ var _TinyCloudNode = class _TinyCloudNode {
     return this.wasmBindings.makeSpaceId(session.address, session.chainId, space);
   }
   expandPermissionEntries(permissions) {
-    return (0, import_sdk_core7.expandPermissionEntries)(permissions);
+    return (0, import_sdk_core8.expandPermissionEntries)(permissions);
   }
   shortServiceName(service) {
-    const short = import_sdk_core7.SERVICE_LONG_TO_SHORT[service];
+    const short = import_sdk_core8.SERVICE_LONG_TO_SHORT[service];
     if (short === void 0) {
       throw new Error(
         `unknown service '${service}' \u2014 no short-form mapping`
@@ -3962,7 +4420,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     return abilities;
   }
   isEncryptionPermissionEntry(entry) {
-    return entry.service === import_sdk_core7.ENCRYPTION_PERMISSION_SERVICE && entry.path.startsWith("urn:tinycloud:encryption:");
+    return entry.service === import_sdk_core8.ENCRYPTION_PERMISSION_SERVICE && entry.path.startsWith("urn:tinycloud:encryption:");
   }
   permissionsToRawAbilities(entries) {
     const rawAbilities = {};
@@ -3995,11 +4453,11 @@ var _TinyCloudNode = class _TinyCloudNode {
   }
   sessionCoversPermissionEntries(session, entries) {
     try {
-      const granted = (0, import_sdk_core7.parseRecapCapabilities)(
+      const granted = (0, import_sdk_core8.parseRecapCapabilities)(
         (siwe) => this.wasmBindings.parseRecapFromSiwe(siwe),
         session.siwe
       );
-      return (0, import_sdk_core7.isCapabilitySubset)(entries, granted).subset;
+      return (0, import_sdk_core8.isCapabilitySubset)(entries, granted).subset;
     } catch {
       return false;
     }
@@ -4330,7 +4788,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (resolvedDelegateDID.endsWith(".eth") && this.config.ensResolver) {
       const address = await this.config.ensResolver.resolveAddress(resolvedDelegateDID);
       if (!address) throw new Error(`Could not resolve ENS name: ${resolvedDelegateDID}`);
-      resolvedDelegateDID = (0, import_sdk_core7.pkhDid)(address, 1);
+      resolvedDelegateDID = (0, import_sdk_core8.pkhDid)(address, 1);
     }
     const entries = legacyParamsToPermissionEntries(
       params.actions,
@@ -4345,7 +4803,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       );
       return result.delegation;
     } catch (err) {
-      if (err instanceof import_sdk_core7.PermissionNotInManifestError) {
+      if (err instanceof import_sdk_core8.PermissionNotInManifestError) {
       } else {
         throw err;
       }
@@ -4402,7 +4860,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       ...prepared,
       signature
     });
-    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core8.activateSessionWithHost)(
       this.config.host,
       delegationSession.delegationHeader
     );
@@ -4424,7 +4882,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     };
     const hasKvActions = params.actions.some((a) => a.startsWith("tinycloud.kv/"));
     if (hasKvActions && params.includePublicSpace !== false) {
-      const publicSpaceId = (0, import_sdk_core7.makePublicSpaceId)(
+      const publicSpaceId = (0, import_sdk_core8.makePublicSpaceId)(
         this.wasmBindings.ensureEip55(session.address),
         session.chainId
       );
@@ -4447,7 +4905,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         ...publicPrepared,
         signature: publicSignature
       });
-      const publicActivateResult = await (0, import_sdk_core7.activateSessionWithHost)(
+      const publicActivateResult = await (0, import_sdk_core8.activateSessionWithHost)(
         this.config.host,
         publicSession.delegationHeader
       );
@@ -4523,6 +4981,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         delegation,
         targetHost,
         this.wasmBindings.invoke,
+        this.wasmBindings.invokeAny,
         this.config.telemetry
       );
     }
@@ -4552,7 +5011,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       ...prepared,
       signature
     });
-    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core8.activateSessionWithHost)(
       targetHost,
       invokerSession.delegationHeader
     );
@@ -4588,6 +5047,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       delegation,
       targetHost,
       this.wasmBindings.invoke,
+      this.wasmBindings.invokeAny,
       this.config.telemetry
     );
   }
@@ -4658,7 +5118,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       ...prepared,
       signature
     });
-    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core8.activateSessionWithHost)(
       targetHost,
       subDelegationSession.delegationHeader
     );
@@ -4694,7 +5154,7 @@ _TinyCloudNode.SESSION_EXPIRY_SAFETY_MARGIN_MS = 6e4;
 var TinyCloudNode = _TinyCloudNode;
 
 // src/core.ts
-var import_sdk_core10 = require("@tinycloud/sdk-core");
+var import_sdk_core11 = require("@tinycloud/sdk-core");
 
 // src/delegation.ts
 function serializeDelegation(delegation) {
@@ -4713,7 +5173,6 @@ function deserializeDelegation(data) {
 }
 
 // src/core.ts
-var import_sdk_core11 = require("@tinycloud/sdk-core");
 var import_sdk_core12 = require("@tinycloud/sdk-core");
 var import_sdk_core13 = require("@tinycloud/sdk-core");
 var import_sdk_core14 = require("@tinycloud/sdk-core");
@@ -4722,6 +5181,7 @@ var import_sdk_core16 = require("@tinycloud/sdk-core");
 var import_sdk_core17 = require("@tinycloud/sdk-core");
 var import_sdk_core18 = require("@tinycloud/sdk-core");
 var import_sdk_core19 = require("@tinycloud/sdk-core");
+var import_sdk_core20 = require("@tinycloud/sdk-core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCOUNT_REGISTRY_PATH,
@@ -4762,6 +5222,7 @@ var import_sdk_core19 = require("@tinycloud/sdk-core");
   SpaceErrorCodes,
   SpaceService,
   TinyCloud,
+  TinyCloudDebugLogger,
   TinyCloudNode,
   UnsupportedFeatureError,
   VAULT_PERMISSION_SERVICE,
@@ -4777,8 +5238,10 @@ var import_sdk_core19 = require("@tinycloud/sdk-core");
   canonicalizeNetworkId,
   canonicalizeSecretScope,
   checkNodeInfo,
+  clearTinyCloudDebugLogs,
   composeManifestRequest,
   createCapabilityKeyRegistry,
+  createOpenKeyCallbackSigningStrategy,
   createSharingService,
   createSpaceService,
   createVaultCrypto,
@@ -4788,9 +5251,13 @@ var import_sdk_core19 = require("@tinycloud/sdk-core");
   deserializeDelegation,
   didCacheKey,
   didEquals,
+  disableTinyCloudDebug,
+  enableTinyCloudDebug,
   expandActionShortNames,
   expandPermissionEntries,
   expandPermissionEntry,
+  getTinyCloudDebugLogs,
+  installTinyCloudDebugGlobals,
   isCapabilitySubset,
   isEvmAddress,
   loadManifest,
@@ -4808,6 +5275,7 @@ var import_sdk_core19 = require("@tinycloud/sdk-core");
   resolveSecretPath,
   resourceCapabilitiesToSpaceAbilitiesMap,
   serializeDelegation,
+  tinyCloudDebugLogger,
   validateManifest
 });
 //# sourceMappingURL=core.cjs.map