@tinycloud/node-sdk 2.4.0-beta.1 → 2.4.0-beta.11

package/dist/core.cjs

@@ -30,94 +30,95 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/core.ts
 var core_exports = {};
 __export(core_exports, {
-  ACCOUNT_REGISTRY_PATH: () => import_sdk_core9.ACCOUNT_REGISTRY_PATH,
-  ACCOUNT_REGISTRY_SPACE: () => import_sdk_core9.ACCOUNT_REGISTRY_SPACE,
-  AutoApproveSpaceCreationHandler: () => import_sdk_core8.AutoApproveSpaceCreationHandler,
-  CapabilityKeyRegistry: () => import_sdk_core15.CapabilityKeyRegistry,
-  CapabilityKeyRegistryErrorCodes: () => import_sdk_core15.CapabilityKeyRegistryErrorCodes,
-  DEFAULT_MANIFEST_SPACE: () => import_sdk_core9.DEFAULT_MANIFEST_SPACE,
-  DEFAULT_MANIFEST_VERSION: () => import_sdk_core9.DEFAULT_MANIFEST_VERSION,
-  DEFAULT_SIGNED_READ_URL_EXPIRY_MS: () => import_sdk_core10.DEFAULT_SIGNED_READ_URL_EXPIRY_MS,
-  DataVaultService: () => import_sdk_core13.DataVaultService,
-  DatabaseHandle: () => import_sdk_core11.DatabaseHandle,
+  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,
   DelegatedAccess: () => DelegatedAccess,
-  DelegationErrorCodes: () => import_sdk_core14.DelegationErrorCodes,
-  DelegationManager: () => import_sdk_core14.DelegationManager,
-  DuckDbAction: () => import_sdk_core12.DuckDbAction,
-  DuckDbDatabaseHandle: () => import_sdk_core12.DuckDbDatabaseHandle,
-  DuckDbService: () => import_sdk_core12.DuckDbService,
+  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,
   FileSessionStorage: () => FileSessionStorage,
-  IdentityParseError: () => import_sdk_core8.IdentityParseError,
-  KVService: () => import_sdk_core10.KVService,
-  ManifestValidationError: () => import_sdk_core9.ManifestValidationError,
+  IdentityParseError: () => import_sdk_core9.IdentityParseError,
+  KVService: () => import_sdk_core11.KVService,
+  ManifestValidationError: () => import_sdk_core10.ManifestValidationError,
   MemorySessionStorage: () => MemorySessionStorage,
   NodeUserAuthorization: () => NodeUserAuthorization,
-  PermissionNotInManifestError: () => import_sdk_core9.PermissionNotInManifestError,
-  PrefixedKVService: () => import_sdk_core10.PrefixedKVService,
-  ProtocolMismatchError: () => import_sdk_core17.ProtocolMismatchError,
-  SECRET_NAME_RE: () => import_sdk_core13.SECRET_NAME_RE,
-  SQLAction: () => import_sdk_core11.SQLAction,
-  SQLService: () => import_sdk_core11.SQLService,
-  SecretsService: () => import_sdk_core13.SecretsService,
-  ServiceContext: () => import_sdk_core18.ServiceContext,
-  SessionExpiredError: () => import_sdk_core9.SessionExpiredError,
-  SharingService: () => import_sdk_core14.SharingService,
-  SilentNotificationHandler: () => import_sdk_core8.SilentNotificationHandler,
-  Space: () => import_sdk_core16.Space,
-  SpaceErrorCodes: () => import_sdk_core16.SpaceErrorCodes,
-  SpaceService: () => import_sdk_core16.SpaceService,
-  TinyCloud: () => import_sdk_core7.TinyCloud,
+  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,
   TinyCloudNode: () => TinyCloudNode,
-  UnsupportedFeatureError: () => import_sdk_core17.UnsupportedFeatureError,
-  VAULT_PERMISSION_SERVICE: () => import_sdk_core9.VAULT_PERMISSION_SERVICE,
-  VaultHeaders: () => import_sdk_core13.VaultHeaders,
-  VaultPublicSpaceKVActions: () => import_sdk_core13.VaultPublicSpaceKVActions,
-  VersionCheckError: () => import_sdk_core17.VersionCheckError,
+  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,
   WasmKeyProvider: () => WasmKeyProvider,
-  addressStorageKey: () => import_sdk_core8.addressStorageKey,
-  buildSpaceUri: () => import_sdk_core16.buildSpaceUri,
-  canonicalizeAddress: () => import_sdk_core8.canonicalizeAddress,
-  canonicalizeDid: () => import_sdk_core8.canonicalizeDid,
-  canonicalizeDidUrl: () => import_sdk_core8.canonicalizeDidUrl,
-  canonicalizeNetworkId: () => import_sdk_core8.canonicalizeNetworkId,
-  canonicalizeSecretScope: () => import_sdk_core13.canonicalizeSecretScope,
-  checkNodeInfo: () => import_sdk_core17.checkNodeInfo,
-  composeManifestRequest: () => import_sdk_core9.composeManifestRequest,
-  createCapabilityKeyRegistry: () => import_sdk_core15.createCapabilityKeyRegistry,
-  createSharingService: () => import_sdk_core14.createSharingService,
-  createSpaceService: () => import_sdk_core16.createSpaceService,
-  createVaultCrypto: () => import_sdk_core13.createVaultCrypto,
+  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,
   createWasmKeyProvider: () => createWasmKeyProvider,
   defaultSignStrategy: () => defaultSignStrategy,
-  defaultSpaceCreationHandler: () => import_sdk_core8.defaultSpaceCreationHandler,
+  defaultSpaceCreationHandler: () => import_sdk_core9.defaultSpaceCreationHandler,
   deserializeDelegation: () => deserializeDelegation,
-  didCacheKey: () => import_sdk_core8.didCacheKey,
-  didEquals: () => import_sdk_core8.didEquals,
-  expandActionShortNames: () => import_sdk_core9.expandActionShortNames,
-  expandPermissionEntries: () => import_sdk_core9.expandPermissionEntries,
-  expandPermissionEntry: () => import_sdk_core9.expandPermissionEntry,
-  isCapabilitySubset: () => import_sdk_core9.isCapabilitySubset,
-  isEvmAddress: () => import_sdk_core8.isEvmAddress,
-  loadManifest: () => import_sdk_core9.loadManifest,
-  makePkhSpaceId: () => import_sdk_core8.makePkhSpaceId,
-  makePublicSpaceId: () => import_sdk_core16.makePublicSpaceId,
-  parseCanonicalNetworkId: () => import_sdk_core8.parseCanonicalNetworkId,
-  parseExpiry: () => import_sdk_core9.parseExpiry,
-  parsePkhDid: () => import_sdk_core8.parsePkhDid,
-  parseSpaceUri: () => import_sdk_core16.parseSpaceUri,
-  pkhDid: () => import_sdk_core8.pkhDid,
-  principalDid: () => import_sdk_core8.principalDid,
-  principalDidEquals: () => import_sdk_core8.principalDidEquals,
-  resolveManifest: () => import_sdk_core9.resolveManifest,
-  resolveSecretListPrefix: () => import_sdk_core13.resolveSecretListPrefix,
-  resolveSecretPath: () => import_sdk_core13.resolveSecretPath,
-  resourceCapabilitiesToSpaceAbilitiesMap: () => import_sdk_core9.resourceCapabilitiesToSpaceAbilitiesMap,
+  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,
   serializeDelegation: () => serializeDelegation,
-  validateManifest: () => import_sdk_core9.validateManifest
+  validateManifest: () => import_sdk_core10.validateManifest
 });
 module.exports = __toCommonJS(core_exports);
-var import_sdk_core7 = require("@tinycloud/sdk-core");
 var import_sdk_core8 = require("@tinycloud/sdk-core");
+var import_sdk_core9 = require("@tinycloud/sdk-core");
 
 // src/storage/MemorySessionStorage.ts
 var MemorySessionStorage = class {
@@ -317,6 +318,25 @@ var import_sdk_core2 = require("@tinycloud/sdk-core");
 var defaultSignStrategy = { type: "auto-sign" };
 
 // src/authorization/NodeUserAuthorization.ts
+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);
+  } catch {
+    return actual === expected;
+  }
+}
+function addRawAbility(rawAbilities, resource, action) {
+  const actions = rawAbilities[resource];
+  if (actions === void 0) {
+    rawAbilities[resource] = [action];
+    return;
+  }
+  if (!actions.includes(action)) {
+    actions.push(action);
+  }
+}
 var NodeUserAuthorization = class {
   constructor(config) {
     this.extensions = [];
@@ -343,6 +363,7 @@ var NodeUserAuthorization = class {
         "": [
           "tinycloud.sql/read",
           "tinycloud.sql/write",
+          "tinycloud.sql/ddl",
           "tinycloud.sql/admin",
           "tinycloud.sql/export"
         ]
@@ -434,12 +455,48 @@ 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) {
+  setRestoredTinyCloudSession(session, hosts) {
     const address = (0, import_sdk_core2.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) {
@@ -546,20 +603,18 @@ var NodeUserAuthorization = class {
       };
     }
     const rawAbilities = {};
+    const currentDid = (0, import_sdk_core2.pkhDid)(address, chainId);
     const spaceResources = request.resources.filter((entry) => {
       if (entry.service !== import_sdk_core2.ENCRYPTION_PERMISSION_SERVICE) {
         return true;
       }
-      const existing = rawAbilities[entry.path];
-      if (existing === void 0) {
-        rawAbilities[entry.path] = [...entry.actions];
-      } else {
-        const seen = new Set(existing);
-        for (const action of entry.actions) {
-          if (!seen.has(action)) {
-            existing.push(action);
-            seen.add(action);
-          }
+      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);
+        if (didPrincipalMatches(parsed.ownerDid, currentDid)) {
+          addRawAbility(rawAbilities, entry.path, NETWORK_CREATE_ACTION);
         }
       }
       return false;
@@ -638,6 +693,7 @@ 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);
@@ -680,6 +736,7 @@ 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)(
@@ -861,7 +918,8 @@ 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;
@@ -1028,7 +1086,8 @@ var NodeUserAuthorization = class {
       },
       expiresAt,
       createdAt,
-      version: "1.0"
+      version: "1.0",
+      tinycloudHosts: this.tinycloudHosts
     };
     await this.sessionStorage.save(address, persistedData);
     this._session = clientSession;
@@ -1119,32 +1178,35 @@ var NodeUserAuthorization = class {
 };
 
 // src/TinyCloudNode.ts
-var import_sdk_core6 = require("@tinycloud/sdk-core");
+var import_sdk_core7 = require("@tinycloud/sdk-core");
 
-// src/DelegatedAccess.ts
+// src/account/AccountService.ts
 var import_sdk_core3 = require("@tinycloud/sdk-core");
+
+// src/DelegatedAccess.ts
+var import_sdk_core4 = require("@tinycloud/sdk-core");
 var DelegatedAccess = class {
   constructor(session, delegation, host, invoke, telemetry) {
     this.session = session;
     this._delegation = delegation;
     this.host = host;
-    this._serviceContext = new import_sdk_core3.ServiceContext({
+    this._serviceContext = new import_sdk_core4.ServiceContext({
       invoke,
       fetch: globalThis.fetch.bind(globalThis),
       hosts: [host],
       telemetry
     });
     const prefix = this._delegation.path.replace(/\/$/, "");
-    this._kv = new import_sdk_core3.KVService({ prefix });
+    this._kv = new import_sdk_core4.KVService({ prefix });
     this._kv.initialize(this._serviceContext);
     this._serviceContext.registerService("kv", this._kv);
-    this._sql = new import_sdk_core3.SQLService({});
+    this._sql = new import_sdk_core4.SQLService({});
     this._sql.initialize(this._serviceContext);
     this._serviceContext.registerService("sql", this._sql);
-    this._duckdb = new import_sdk_core3.DuckDbService({});
+    this._duckdb = new import_sdk_core4.DuckDbService({});
     this._duckdb.initialize(this._serviceContext);
     this._serviceContext.registerService("duckdb", this._duckdb);
-    this._hooks = new import_sdk_core3.HooksService({});
+    this._hooks = new import_sdk_core4.HooksService({});
     this._hooks.initialize(this._serviceContext);
     this._serviceContext.registerService("hooks", this._hooks);
     const serviceSession = {
@@ -1294,7 +1356,7 @@ function createWasmKeyProvider(sessionManager) {
 }
 
 // src/delegateToHelpers.ts
-var import_sdk_core4 = require("@tinycloud/sdk-core");
+var import_sdk_core5 = require("@tinycloud/sdk-core");
 function legacyParamsToPermissionEntries(actions, path, spaceIdOverride) {
   const byService = /* @__PURE__ */ new Map();
   for (const a of actions) {
@@ -1325,7 +1387,7 @@ function legacyParamsToPermissionEntries(actions, path, spaceIdOverride) {
   }
   return entries;
 }
-var DEFAULT_DELEGATION_EXPIRY_MS = import_sdk_core4.EXPIRY.SESSION_MS;
+var DEFAULT_DELEGATION_EXPIRY_MS = import_sdk_core5.EXPIRY.SESSION_MS;
 function resolveExpiryMs(expiry) {
   if (expiry === void 0) {
     return DEFAULT_DELEGATION_EXPIRY_MS;
@@ -1338,10 +1400,10 @@ function resolveExpiryMs(expiry) {
     }
     return expiry;
   }
-  return (0, import_sdk_core4.parseExpiry)(expiry);
+  return (0, import_sdk_core5.parseExpiry)(expiry);
 }
 function extractSiweExpiration(siwe) {
-  const parsed = new import_sdk_core4.SiweMessage(siwe);
+  const parsed = new import_sdk_core5.SiweMessage(siwe);
   if (parsed.expirationTime === void 0 || parsed.expirationTime === null) {
     return void 0;
   }
@@ -1355,7 +1417,7 @@ function extractSiweExpiration(siwe) {
 }
 
 // src/NodeSecretsService.ts
-var import_sdk_core5 = require("@tinycloud/sdk-core");
+var import_sdk_core6 = require("@tinycloud/sdk-core");
 var SECRETS_SPACE = "secrets";
 function ok() {
   return { ok: true, data: void 0 };
@@ -1388,7 +1450,7 @@ function secretActionName(action) {
 }
 function secretPermissionEntries(name, options, action, encryptionNetworkId) {
   const entries = [];
-  const path = action === "list" ? (0, import_sdk_core5.resolveSecretListPrefix)(options) : (0, import_sdk_core5.resolveSecretPath)(name, options).permissionPaths.vault;
+  const path = action === "list" ? (0, import_sdk_core6.resolveSecretListPrefix)(options) : (0, import_sdk_core6.resolveSecretPath)(name, options).permissionPaths.vault;
   entries.push({
     service: "tinycloud.kv",
     space: SECRETS_SPACE,
@@ -1467,7 +1529,7 @@ var NodeSecretsService = class {
       );
     } catch (error) {
       return secretsError(
-        import_sdk_core5.ErrorCodes.INVALID_INPUT,
+        import_sdk_core6.ErrorCodes.INVALID_INPUT,
         error instanceof Error ? error.message : String(error),
         error instanceof Error ? error : void 0
       );
@@ -1477,7 +1539,7 @@ var NodeSecretsService = class {
     }
     if (!this.config.canEscalate()) {
       return secretsError(
-        import_sdk_core5.ErrorCodes.PERMISSION_DENIED,
+        import_sdk_core6.ErrorCodes.PERMISSION_DENIED,
         `Cannot autosign ${displayActionUrn(action)} for ${target}; TinyCloudNode needs wallet mode with a signer or privateKey.`
       );
     }
@@ -1486,7 +1548,7 @@ var NodeSecretsService = class {
       return this.restoreUnlockAfterEscalation();
     } catch (error) {
       return secretsError(
-        import_sdk_core5.ErrorCodes.PERMISSION_DENIED,
+        import_sdk_core6.ErrorCodes.PERMISSION_DENIED,
         error instanceof Error ? error.message : `Autosign escalation for ${displayActionUrn(action)} on ${target} failed.`,
         error instanceof Error ? error : void 0
       );
@@ -1507,10 +1569,10 @@ var NodeSecretsService = class {
       return false;
     }
     const manifests = Array.isArray(manifest) ? manifest : [manifest];
-    const requestedEntries = (0, import_sdk_core5.expandPermissionEntries)(permissionEntries);
+    const requestedEntries = (0, import_sdk_core6.expandPermissionEntries)(permissionEntries);
     return requestedEntries.every(
       (entry) => manifests.some((candidate) => {
-        const resolved = (0, import_sdk_core5.resolveManifest)(candidate);
+        const resolved = (0, import_sdk_core6.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))
         );
@@ -1522,13 +1584,13 @@ var NodeSecretsService = class {
 // src/TinyCloudNode.ts
 var DEFAULT_HOST = "https://node.tinycloud.xyz";
 var DEFAULT_ENCRYPTION_NETWORK_NAME = "default";
-var NETWORK_CREATE_ACTION = "tinycloud.encryption/network.create";
-var DECRYPT_ACTION = "tinycloud.encryption/decrypt";
+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_core6.EXPIRY.SESSION_MS;
-function didPrincipalMatches(actual, expected) {
+var DEFAULT_SESSION_EXPIRATION_MS = import_sdk_core7.EXPIRY.SESSION_MS;
+function didPrincipalMatches2(actual, expected) {
   try {
-    return (0, import_sdk_core6.principalDidEquals)(actual, expected);
+    return (0, import_sdk_core7.principalDidEquals)(actual, expected);
   } catch {
     return actual === expected;
   }
@@ -1694,12 +1756,12 @@ var _TinyCloudNode = class _TinyCloudNode {
       throw new Error("Failed to get session key JWK");
     }
     this.sessionKeyJwk = JSON.parse(jwkStr);
-    this._capabilityRegistry = new import_sdk_core6.CapabilityKeyRegistry();
+    this._capabilityRegistry = new import_sdk_core7.CapabilityKeyRegistry();
     this._keyProvider = new WasmKeyProvider({
       sessionManager: this.sessionManager
     });
-    this.notificationHandler = config.notificationHandler ?? new import_sdk_core6.SilentNotificationHandler();
-    this._sharingService = new import_sdk_core6.SharingService({
+    this.notificationHandler = config.notificationHandler ?? new import_sdk_core7.SilentNotificationHandler();
+    this._sharingService = new import_sdk_core7.SharingService({
       hosts: [this.config.host],
       // session: undefined - not needed for receive()
       invoke: this.invokeWithRuntimePermissions,
@@ -1709,8 +1771,8 @@ var _TinyCloudNode = class _TinyCloudNode {
       // delegationManager: undefined - not needed for receive()
       createKVService: (config2) => {
         const prefix = config2.pathPrefix?.replace(/\/$/, "");
-        const kvService = new import_sdk_core6.KVService({ prefix });
-        const kvContext = new import_sdk_core6.ServiceContext({
+        const kvService = new import_sdk_core7.KVService({ prefix });
+        const kvContext = new import_sdk_core7.ServiceContext({
           invoke: config2.invoke,
           fetch: config2.fetch ?? globalThis.fetch.bind(globalThis),
           hosts: config2.hosts,
@@ -1770,7 +1832,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       capabilityRequest: config.capabilityRequest,
       includeAccountRegistryPermissions: config.includeAccountRegistryPermissions
     });
-    this.tc = new import_sdk_core6.TinyCloud(this.auth, {
+    this.tc = new import_sdk_core7.TinyCloud(this.auth, {
       invokeAny: this.invokeAnyWithRuntimePermissions,
       telemetry: config.telemetry
     });
@@ -1831,7 +1893,7 @@ var _TinyCloudNode = class _TinyCloudNode {
    */
   get did() {
     if (this._address) {
-      return (0, import_sdk_core6.pkhDid)(this._address, this._chainId);
+      return (0, import_sdk_core7.pkhDid)(this._address, this._chainId);
     }
     return this.sessionManager.getDID(this.sessionKeyId);
   }
@@ -1865,6 +1927,37 @@ var _TinyCloudNode = class _TinyCloudNode {
   get spaceId() {
     return this.auth?.tinyCloudSession?.spaceId;
   }
+  /**
+   * Get the account space ID for this wallet identity.
+   * Available after wallet-backed sign-in or a restored session with address metadata.
+   */
+  get accountSpaceId() {
+    if (!this._address) {
+      return void 0;
+    }
+    return this.wasmBindings.makeSpaceId(this._address, this._chainId, import_sdk_core7.ACCOUNT_REGISTRY_SPACE);
+  }
+  /**
+   * Account-level application and delegation helpers.
+   */
+  get account() {
+    if (!this._account) {
+      this._account = new import_sdk_core3.AccountService({
+        getDid: () => this.did,
+        getHost: () => this.hosts[0] ?? this.config.host,
+        getPrimarySpaceId: () => this.spaceId,
+        getAccountSpaceId: () => this.accountSpaceId,
+        getSpaces: () => this.spaces,
+        getAccountDb: () => this.accountSpaceId ? this.sqlForSpace(this.accountSpaceId).db("account") : void 0,
+        ensureAccountSpaceHosted: async () => {
+          if (this.accountSpaceId && this.auth) {
+            await this.ensureOwnedSpaceHostedById(this.accountSpaceId);
+          }
+        }
+      });
+    }
+    return this._account;
+  }
   /**
    * Get the current TinyCloud session.
    * Available after signIn().
@@ -1886,7 +1979,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       );
     }
     await this.wasmBindings.ensureInitialized?.();
-    this._address = (0, import_sdk_core6.canonicalizeAddress)(await this.signer.getAddress());
+    this._address = (0, import_sdk_core7.canonicalizeAddress)(await this.signer.getAddress());
     this._chainId = await this.signer.getChainId();
     this._kv = void 0;
     this._sql = void 0;
@@ -1902,10 +1995,11 @@ var _TinyCloudNode = class _TinyCloudNode {
     await this.tc.signIn(options);
     this.syncResolvedHostFromAuth();
     this.initializeServices();
+    await this.ensureRequestedEncryptionNetworks();
     if (this.config.manifest === void 0 && this.config.capabilityRequest === void 0) {
-      await this.ensureOwnedSpaceHosted(this.ownedSpaceId("secrets"));
+      await this.ensureOwnedSpaceHostedById(this.ownedSpaceId("secrets"));
     }
-    await this.writeManifestRegistryRecords();
+    this.scheduleAccountRegistrySync();
     this.notificationHandler.success("Successfully signed in");
   }
   ownedSpaceId(name) {
@@ -1922,23 +2016,69 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!this.auth || !this.signer) {
       throw new Error("Manifest registry write requires wallet mode");
     }
-    const accountSpaceId = this.ownedSpaceId(import_sdk_core6.ACCOUNT_REGISTRY_SPACE);
-    await this.ensureOwnedSpaceHosted(accountSpaceId);
-    const accountKV = this.spaces.get(accountSpaceId).kv;
-    for (const record of request.registryRecords) {
-      const result = await accountKV.put(record.key, {
-        app_id: record.app_id,
-        manifests: record.manifests,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      if (!result.ok) {
-        throw new Error(
-          `Failed to write manifest registry record ${record.key}: ${result.error.message}`
-        );
+    const accountSpaceId = this.ownedSpaceId(import_sdk_core7.ACCOUNT_REGISTRY_SPACE);
+    await this.ensureOwnedSpaceHostedById(accountSpaceId);
+    const result = await this.account.applications.register(request.manifests);
+    if (!result.ok) {
+      throw new Error(
+        `Failed to write manifest registry records: ${result.error.message}`
+      );
+    }
+  }
+  scheduleAccountRegistrySync() {
+    void this.withAccountRegistryRetry(async () => {
+      await this.writeManifestRegistryRecords();
+      const spaces = await this.account.spaces.syncAccessible();
+      if (!spaces.ok) {
+        throw new Error(`Failed to sync account spaces: ${spaces.error.message}`);
+      }
+    });
+  }
+  async withAccountRegistryRetry(task) {
+    const delays = [250, 1e3, 3e3];
+    let lastError;
+    for (let attempt = 0; attempt < delays.length; attempt += 1) {
+      try {
+        await task();
+        return;
+      } catch (error) {
+        lastError = error;
+        if (attempt < delays.length - 1) {
+          await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
+        }
       }
     }
+    console.warn(
+      "TinyCloud account registry sync failed after retries",
+      lastError
+    );
+  }
+  requestedEncryptionNetworkIds() {
+    const request = this.capabilityRequest;
+    if (!request) {
+      return [];
+    }
+    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)) {
+        networkIds.add(resource.path);
+      }
+    }
+    return [...networkIds];
   }
-  async ensureOwnedSpaceHosted(spaceId) {
+  async ensureRequestedEncryptionNetworks() {
+    if (!this.signer || !this.auth) {
+      return;
+    }
+    for (const networkId of this.requestedEncryptionNetworkIds()) {
+      const parsed = (0, import_sdk_core7.parseNetworkId)(networkId);
+      if (!didPrincipalMatches2(parsed.ownerDid, this.did)) {
+        continue;
+      }
+      await this.ensureEncryptionNetwork(networkId);
+    }
+  }
+  async ensureOwnedSpaceHostedById(spaceId) {
     if (!this.auth) {
       throw new Error("Owned space hosting requires wallet mode");
     }
@@ -1950,7 +2090,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!host) {
       throw new Error("Owned space hosting requires a TinyCloud host");
     }
-    const activation = await (0, import_sdk_core6.activateSessionWithHost)(host, session.delegationHeader);
+    const activation = await (0, import_sdk_core7.activateSessionWithHost)(host, session.delegationHeader);
     if (activation.success && !activation.skipped?.includes(spaceId)) {
       return;
     }
@@ -1964,7 +2104,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_core6.activateSessionWithHost)(host, session.delegationHeader);
+    const retry = await (0, import_sdk_core7.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"}`
@@ -1981,7 +2121,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
@@ -2006,7 +2146,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!hosted) {
       throw new Error(`Failed to host owned space: ${spaceId}`);
     }
-    const activation = await (0, import_sdk_core6.activateSessionWithHost)(
+    const activation = await (0, import_sdk_core7.activateSessionWithHost)(
       host,
       this.auth.tinyCloudSession.delegationHeader
     );
@@ -2015,8 +2155,40 @@ var _TinyCloudNode = class _TinyCloudNode {
         `Failed to activate session for owned space ${spaceId}: ${activation.error ?? "space was skipped"}`
       );
     }
+    void this.account.spaces.register({
+      spaceId,
+      name,
+      ownerDid: this.did,
+      type: "owned",
+      permissions: ["*"],
+      status: "active"
+    }).catch(() => {
+    });
     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>`) and hosts it via the
+   * host-SIWE delegation flow. The host SIWE is idempotent server-side, so it
+   * is safe to call whether or not the space already exists; do not gate it on
+   * a prior existence check. Must be called after {@link signIn}.
+   *
+   * @param name - The owned space name (e.g. `"secrets"`).
+   * @returns The hosted owned-space URI.
+   */
+  async ensureOwnedSpaceHosted(name) {
+    return this.hostOwnedSpace(name);
+  }
   /**
    * Restore a previously established session from stored delegation data.
    *
@@ -2039,30 +2211,38 @@ var _TinyCloudNode = class _TinyCloudNode {
     this._spaceService = void 0;
     this._serviceContext = void 0;
     this.runtimePermissionGrants = [];
-    const restoredAddress = sessionData.address ? (0, import_sdk_core6.canonicalizeAddress)(sessionData.address) : void 0;
+    const restoredAddress = sessionData.address ? (0, import_sdk_core7.canonicalizeAddress)(sessionData.address) : void 0;
     if (restoredAddress) {
       this._address = restoredAddress;
     }
     if (sessionData.chainId) {
       this._chainId = sessionData.chainId;
     }
-    this._serviceContext = new import_sdk_core6.ServiceContext({
+    const resolvedHost = await this.resolveRestoredHost(
+      sessionData.tinycloudHosts,
+      restoredAddress,
+      sessionData.chainId
+    );
+    if (resolvedHost) {
+      this.config.host = resolvedHost;
+    }
+    this._serviceContext = new import_sdk_core7.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_core6.KVService({});
+    this._kv = new import_sdk_core7.KVService({});
     this._kv.initialize(this._serviceContext);
     this._serviceContext.registerService("kv", this._kv);
-    this._sql = new import_sdk_core6.SQLService({});
+    this._sql = new import_sdk_core7.SQLService({});
     this._sql.initialize(this._serviceContext);
     this._serviceContext.registerService("sql", this._sql);
-    this._duckdb = new import_sdk_core6.DuckDbService({});
+    this._duckdb = new import_sdk_core7.DuckDbService({});
     this._duckdb.initialize(this._serviceContext);
     this._serviceContext.registerService("duckdb", this._duckdb);
-    this._hooks = new import_sdk_core6.HooksService({});
+    this._hooks = new import_sdk_core7.HooksService({});
     this._hooks.initialize(this._serviceContext);
     this._serviceContext.registerService("hooks", this._hooks);
     const serviceSession = {
@@ -2091,12 +2271,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_core7.resolveTinyCloudHosts)((0, import_sdk_core7.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
@@ -2161,7 +2374,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       capabilityRequest: this.config.capabilityRequest,
       includeAccountRegistryPermissions: this.config.includeAccountRegistryPermissions
     });
-    this.tc = new import_sdk_core6.TinyCloud(this.auth, {
+    this.tc = new import_sdk_core7.TinyCloud(this.auth, {
       invokeAny: this.invokeAnyWithRuntimePermissions,
       telemetry: this.config.telemetry
     });
@@ -2206,7 +2419,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       capabilityRequest: this.config.capabilityRequest,
       includeAccountRegistryPermissions: this.config.includeAccountRegistryPermissions
     });
-    this.tc = new import_sdk_core6.TinyCloud(this.auth, {
+    this.tc = new import_sdk_core7.TinyCloud(this.auth, {
       invokeAny: this.invokeAnyWithRuntimePermissions,
       telemetry: this.config.telemetry
     });
@@ -2222,28 +2435,28 @@ var _TinyCloudNode = class _TinyCloudNode {
       return;
     }
     this.tc.initializeServices(this.invokeWithRuntimePermissions, [this.config.host]);
-    this._serviceContext = new import_sdk_core6.ServiceContext({
+    this._serviceContext = new import_sdk_core7.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_core6.KVService({});
+    this._kv = new import_sdk_core7.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_core6.SQLService({});
+      this._sql = new import_sdk_core7.SQLService({});
       this._sql.initialize(this._serviceContext);
       this._serviceContext.registerService("sql", this._sql);
     }
     if (features.length === 0 || features.includes("duckdb")) {
-      this._duckdb = new import_sdk_core6.DuckDbService({});
+      this._duckdb = new import_sdk_core7.DuckDbService({});
       this._duckdb.initialize(this._serviceContext);
       this._serviceContext.registerService("duckdb", this._duckdb);
     }
-    this._hooks = new import_sdk_core6.HooksService({});
+    this._hooks = new import_sdk_core7.HooksService({});
     this._hooks.initialize(this._serviceContext);
     this._serviceContext.registerService("hooks", this._hooks);
     const serviceSession = {
@@ -2261,9 +2474,9 @@ var _TinyCloudNode = class _TinyCloudNode {
     this.initializeV2Services(serviceSession);
   }
   createSpaceScopedKVService(spaceId) {
-    const kvService = new import_sdk_core6.KVService({});
+    const kvService = new import_sdk_core7.KVService({});
     if (this._serviceContext) {
-      const spaceScopedContext = new import_sdk_core6.ServiceContext({
+      const spaceScopedContext = new import_sdk_core7.ServiceContext({
         invoke: this._serviceContext.invoke,
         fetch: this._serviceContext.fetch,
         hosts: this._serviceContext.hosts,
@@ -2328,7 +2541,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         const shared = wasm.vault_x25519_dh(receiverPrivateKey, peerPublic);
         return columnDecrypt(shared, ciphertext);
       },
-      verifyNodeSignature: (nodeId, message, signature) => (0, import_sdk_core6.verifyDidKeyEd25519Signature)(nodeId, message, signature)
+      verifyNodeSignature: (nodeId, message, signature) => (0, import_sdk_core7.verifyDidKeyEd25519Signature)(nodeId, message, signature)
     };
   }
   async fetchNodeId() {
@@ -2399,19 +2612,19 @@ var _TinyCloudNode = class _TinyCloudNode {
         return await response.json();
       }
     };
-    return new import_sdk_core6.EncryptionService({
+    return new import_sdk_core7.EncryptionService({
       crypto,
       signer: {
         signDecryptInvocation: async (input) => {
           const signed = await this.signRawNetworkAuthorization({
             targetNode: input.targetNode,
             networkId: input.networkId,
-            action: DECRYPT_ACTION,
+            action: DECRYPT_ACTION2,
             facts: input.facts
           });
           return {
             ...signed,
-            canonicalBody: (0, import_sdk_core6.canonicalizeEncryptionJson)(
+            canonicalBody: (0, import_sdk_core7.canonicalizeEncryptionJson)(
               input.body
             )
           };
@@ -2423,14 +2636,14 @@ var _TinyCloudNode = class _TinyCloudNode {
       },
       wellKnown: {
         fetchWellKnown: async (principal, discoveryKey) => {
-          if (!this._address || !didPrincipalMatches(principal, this.did)) {
+          if (!this._address || !didPrincipalMatches2(principal, this.did)) {
             return null;
           }
           if (!this.config.host) {
             return null;
           }
-          const publicSpaceId = (0, import_sdk_core6.makePublicSpaceId)(this._address, this._chainId);
-          const result = await import_sdk_core6.TinyCloud.readPublicSpace(this.config.host, publicSpaceId, discoveryKey);
+          const publicSpaceId = (0, import_sdk_core7.makePublicSpaceId)(this._address, this._chainId);
+          const result = await import_sdk_core7.TinyCloud.readPublicSpace(this.config.host, publicSpaceId, discoveryKey);
           if (!result.ok) {
             return null;
           }
@@ -2453,7 +2666,7 @@ var _TinyCloudNode = class _TinyCloudNode {
   }
   createVaultService(spaceId, kv) {
     const wasm = this.wasmBindings;
-    const vaultCrypto = (0, import_sdk_core6.createVaultCrypto)({
+    const vaultCrypto = (0, import_sdk_core7.createVaultCrypto)({
       vault_encrypt: wasm.vault_encrypt,
       vault_decrypt: wasm.vault_decrypt,
       vault_derive_key: wasm.vault_derive_key,
@@ -2463,7 +2676,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       vault_sha256: wasm.vault_sha256
     });
     const self = this;
-    return new import_sdk_core6.DataVaultService({
+    return new import_sdk_core7.DataVaultService({
       spaceId,
       crypto: vaultCrypto,
       encryption: {
@@ -2486,8 +2699,8 @@ var _TinyCloudNode = class _TinyCloudNode {
         get publicKV() {
           return self._publicKV ?? self.tc.publicKV;
         },
-        readPublicSpace: (host, targetSpaceId, key) => import_sdk_core6.TinyCloud.readPublicSpace(host, targetSpaceId, key),
-        makePublicSpaceId: import_sdk_core6.TinyCloud.makePublicSpaceId,
+        readPublicSpace: (host, targetSpaceId, key) => import_sdk_core7.TinyCloud.readPublicSpace(host, targetSpaceId, key),
+        makePublicSpaceId: import_sdk_core7.TinyCloud.makePublicSpaceId,
         did: this.did,
         address: this._address ?? "",
         chainId: this._chainId,
@@ -2500,7 +2713,7 @@ var _TinyCloudNode = class _TinyCloudNode {
    * @internal
    */
   initializeV2Services(serviceSession) {
-    this._capabilityRegistry = new import_sdk_core6.CapabilityKeyRegistry();
+    this._capabilityRegistry = new import_sdk_core7.CapabilityKeyRegistry();
     const tcSession = this.auth?.tinyCloudSession;
     if (tcSession && this._address) {
       const sessionKey = {
@@ -2574,13 +2787,13 @@ var _TinyCloudNode = class _TinyCloudNode {
       }
       this._capabilityRegistry.registerKey(sessionKey, delegations);
     }
-    this._delegationManager = new import_sdk_core6.DelegationManager({
+    this._delegationManager = new import_sdk_core7.DelegationManager({
       hosts: [this.config.host],
       session: serviceSession,
       invoke: this.invokeWithRuntimePermissions,
       fetch: globalThis.fetch.bind(globalThis)
     });
-    this._spaceService = new import_sdk_core6.SpaceService({
+    this._spaceService = new import_sdk_core7.SpaceService({
       hosts: [this.config.host],
       session: serviceSession,
       invoke: this.wasmBindings.invoke,
@@ -2632,6 +2845,9 @@ var _TinyCloudNode = class _TinyCloudNode {
             }
           };
         }
+      },
+      onSpaceRegistered: async (space) => {
+        await this.account.spaces.register(space);
       }
     });
     this._sharingService.updateConfig({
@@ -2737,7 +2953,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         ...prepared,
         signature
       });
-      const activateResult = await (0, import_sdk_core6.activateSessionWithHost)(
+      const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
         host,
         delegationSession.delegationHeader
       );
@@ -2747,7 +2963,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       return {
         cid: delegationSession.delegationCid,
         delegateDID: params.shareKeyDID,
-        delegatorDID: (0, import_sdk_core6.pkhDid)(session.address, session.chainId),
+        delegatorDID: (0, import_sdk_core7.pkhDid)(session.address, session.chainId),
         spaceId: params.spaceId,
         path: params.path,
         actions: params.actions,
@@ -2804,7 +3020,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!this._sql) {
       const features = this.nodeFeatures;
       if (features.length > 0 && !features.includes("sql")) {
-        throw new import_sdk_core6.UnsupportedFeatureError("sql", this.config.host, features);
+        throw new import_sdk_core7.UnsupportedFeatureError("sql", this.config.host, features);
       }
       throw new Error("Not signed in. Call signIn() first.");
     }
@@ -2828,8 +3044,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_core6.SQLService({});
-    const spaceScopedContext = new import_sdk_core6.ServiceContext({
+    const sql = new import_sdk_core7.SQLService({});
+    const spaceScopedContext = new import_sdk_core7.ServiceContext({
       invoke: this._serviceContext.invoke,
       fetch: this._serviceContext.fetch,
       hosts: this._serviceContext.hosts,
@@ -2857,8 +3073,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_core6.KVService({});
-    const spaceScopedContext = new import_sdk_core6.ServiceContext({
+    const kv = new import_sdk_core7.KVService({});
+    const spaceScopedContext = new import_sdk_core7.ServiceContext({
       invoke: this._serviceContext.invoke,
       fetch: this._serviceContext.fetch,
       hosts: this._serviceContext.hosts
@@ -2874,7 +3090,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!this._duckdb) {
       const features = this.nodeFeatures;
       if (features.length > 0 && !features.includes("duckdb")) {
-        throw new import_sdk_core6.UnsupportedFeatureError("duckdb", this.config.host, features);
+        throw new import_sdk_core7.UnsupportedFeatureError("duckdb", this.config.host, features);
       }
       throw new Error("Not signed in. Call signIn() first.");
     }
@@ -2926,16 +3142,16 @@ var _TinyCloudNode = class _TinyCloudNode {
       type: NETWORK_ADMIN_TYPE,
       targetNode,
       networkId,
-      bodyHash: (0, import_sdk_core6.canonicalHashHex)(
+      bodyHash: (0, import_sdk_core7.canonicalHashHex)(
         crypto.sha256,
         body
       ),
-      action: NETWORK_CREATE_ACTION
+      action: NETWORK_CREATE_ACTION2
     };
     const signed = await this.signRawNetworkAuthorization({
       targetNode,
       networkId,
-      action: NETWORK_CREATE_ACTION,
+      action: NETWORK_CREATE_ACTION2,
       facts
     });
     const response = await fetch(`${this.config.host}/encryption/networks`, {
@@ -2944,7 +3160,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         Authorization: signed.authorization,
         "Content-Type": "application/json"
       },
-      body: (0, import_sdk_core6.canonicalizeEncryptionJson)(
+      body: (0, import_sdk_core7.canonicalizeEncryptionJson)(
         body
       )
     });
@@ -2956,12 +3172,19 @@ var _TinyCloudNode = class _TinyCloudNode {
     const created = await response.json();
     return created.descriptor;
   }
-  async ensureEncryptionNetwork(name = DEFAULT_ENCRYPTION_NETWORK_NAME) {
-    const existing = await this.getEncryptionNetwork(name);
+  async ensureEncryptionNetwork(nameOrNetworkId = DEFAULT_ENCRYPTION_NETWORK_NAME) {
+    const networkId = nameOrNetworkId.startsWith("urn:tinycloud:encryption:") ? nameOrNetworkId : this.getDefaultEncryptionNetworkId(nameOrNetworkId);
+    const existing = await this.getEncryptionNetwork(networkId);
     if (existing) {
       return existing;
     }
-    return this.createEncryptionNetwork(name);
+    const parsed = (0, import_sdk_core7.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}`
+      );
+    }
+    return this.createEncryptionNetwork(parsed.name);
   }
   /**
    * App-facing secrets API backed by the `secrets` space vault.
@@ -2988,7 +3211,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       throw new Error("Not signed in. Call signIn() first.");
     }
     if (!this._baseSecrets) {
-      this._baseSecrets = new import_sdk_core6.SecretsService(() => this.space("secrets").vault);
+      this._baseSecrets = new import_sdk_core7.SecretsService(() => this.space("secrets").vault);
     }
     return this._baseSecrets;
   }
@@ -3103,19 +3326,19 @@ var _TinyCloudNode = class _TinyCloudNode {
   async useRuntimeDelegation(delegation) {
     const session = this.currentTinyCloudSession();
     if (!session) {
-      throw new import_sdk_core6.SessionExpiredError(/* @__PURE__ */ new Date(0));
+      throw new import_sdk_core7.SessionExpiredError(/* @__PURE__ */ new Date(0));
     }
     if (delegation.expiry.getTime() <= Date.now()) {
-      throw new import_sdk_core6.SessionExpiredError(delegation.expiry);
+      throw new import_sdk_core7.SessionExpiredError(delegation.expiry);
     }
     const expectedDids = [session.verificationMethod, this.sessionDid];
-    if (!expectedDids.some((did) => didPrincipalMatches(delegation.delegateDID, did))) {
+    if (!expectedDids.some((did) => didPrincipalMatches2(delegation.delegateDID, did))) {
       throw new Error(
         `Runtime delegation targets ${delegation.delegateDID} but this session key is ${session.verificationMethod}.`
       );
     }
     const targetHost = delegation.host ?? this.config.host;
-    const activateResult = await (0, import_sdk_core6.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
       targetHost,
       delegation.delegationHeader
     );
@@ -3142,13 +3365,13 @@ var _TinyCloudNode = class _TinyCloudNode {
     }
     const session = this.currentTinyCloudSession();
     if (!session) {
-      throw new import_sdk_core6.SessionExpiredError(/* @__PURE__ */ new Date(0));
+      throw new import_sdk_core7.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_core6.SessionExpiredError(sessionExpiry);
+        throw new import_sdk_core7.SessionExpiredError(sessionExpiry);
       }
     }
     const expanded = this.expandPermissionEntries(permissions);
@@ -3211,7 +3434,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         ...prepared,
         signature
       });
-      const activateResult = await (0, import_sdk_core6.activateSessionWithHost)(
+      const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
         this.config.host,
         delegatedSession.delegationHeader
       );
@@ -3384,7 +3607,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     ];
     const abilities = { kv: { "": kvActions } };
     const now = /* @__PURE__ */ new Date();
-    const expiryMs = import_sdk_core6.EXPIRY.EPHEMERAL_MS;
+    const expiryMs = import_sdk_core7.EXPIRY.EPHEMERAL_MS;
     const expirationTime = new Date(now.getTime() + expiryMs);
     const prepared = this.wasmBindings.prepareSession({
       abilities,
@@ -3402,7 +3625,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       ...prepared,
       signature
     });
-    const activateResult = await (0, import_sdk_core6.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
       this.config.host,
       delegationSession.delegationHeader
     );
@@ -3429,8 +3652,8 @@ var _TinyCloudNode = class _TinyCloudNode {
       }]);
     }
     if (this._serviceContext) {
-      const publicKV = new import_sdk_core6.KVService({ prefix: "" });
-      const publicContext = new import_sdk_core6.ServiceContext({
+      const publicKV = new import_sdk_core7.KVService({ prefix: "" });
+      const publicContext = new import_sdk_core7.ServiceContext({
         invoke: this.invokeWithRuntimePermissions,
         fetch: this._serviceContext.fetch,
         hosts: this._serviceContext.hosts,
@@ -3557,14 +3780,14 @@ var _TinyCloudNode = class _TinyCloudNode {
   async delegateTo(did, permissions, options) {
     const session = this.currentTinyCloudSession();
     if (!session) {
-      throw new import_sdk_core6.SessionExpiredError(/* @__PURE__ */ new Date(0));
+      throw new import_sdk_core7.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_core6.SessionExpiredError(sessionExpiry);
+        throw new import_sdk_core7.SessionExpiredError(sessionExpiry);
       }
     }
     if (!Array.isArray(permissions) || permissions.length === 0) {
@@ -3593,11 +3816,11 @@ var _TinyCloudNode = class _TinyCloudNode {
       );
       return { delegation: delegation2, prompted: true };
     }
-    const granted = (0, import_sdk_core6.parseRecapCapabilities)(
+    const granted = (0, import_sdk_core7.parseRecapCapabilities)(
       (siwe) => this.wasmBindings.parseRecapFromSiwe(siwe),
       session.siwe
     );
-    const { subset, missing } = (0, import_sdk_core6.isCapabilitySubset)(expandedEntries, granted);
+    const { subset, missing } = (0, import_sdk_core7.isCapabilitySubset)(expandedEntries, granted);
     if (!subset) {
       const runtimeGrant = this.findGrantForOperations(
         this.permissionEntriesToOperations(expandedEntries, session)
@@ -3605,7 +3828,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_core6.SessionExpiredError(runtimeGrant.expiresAt);
+          throw new import_sdk_core7.SessionExpiredError(runtimeGrant.expiresAt);
         }
         const runtimeExpiration = runtimeGrant.expiresAt < effectiveExpiration ? runtimeGrant.expiresAt : effectiveExpiration;
         const delegation2 = await this.createDelegationViaRuntimeGrant(
@@ -3616,7 +3839,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         );
         return { delegation: delegation2, prompted: false };
       }
-      throw new import_sdk_core6.PermissionNotInManifestError(missing, granted);
+      throw new import_sdk_core7.PermissionNotInManifestError(missing, granted);
     }
     const delegation = await this.createDelegationViaWasmPath(
       did,
@@ -3638,7 +3861,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       );
     }
     const target = request.delegationTargets.find(
-      (entry) => didPrincipalMatches(entry.did, did)
+      (entry) => didPrincipalMatches2(entry.did, did)
     );
     if (!target) {
       throw new Error(`No manifest delegation target found for DID ${did}`);
@@ -3698,7 +3921,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_core6.SERVICE_LONG_TO_SHORT[entry.service];
+      const shortService = import_sdk_core7.SERVICE_LONG_TO_SHORT[entry.service];
       if (shortService === void 0) {
         throw new Error(
           `delegateTo: unknown service '${entry.service}' \u2014 no short-form mapping`
@@ -3738,7 +3961,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     });
     const primary = result.resources[0];
     const delegationHeader = { Authorization: result.delegation };
-    const activateResult = await (0, import_sdk_core6.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
       this.config.host,
       delegationHeader
     );
@@ -3773,7 +3996,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_core6.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
       targetHost,
       delegationHeader
     );
@@ -3814,10 +4037,10 @@ var _TinyCloudNode = class _TinyCloudNode {
     return this.wasmBindings.makeSpaceId(session.address, session.chainId, space);
   }
   expandPermissionEntries(permissions) {
-    return (0, import_sdk_core6.expandPermissionEntries)(permissions);
+    return (0, import_sdk_core7.expandPermissionEntries)(permissions);
   }
   shortServiceName(service) {
-    const short = import_sdk_core6.SERVICE_LONG_TO_SHORT[service];
+    const short = import_sdk_core7.SERVICE_LONG_TO_SHORT[service];
     if (short === void 0) {
       throw new Error(
         `unknown service '${service}' \u2014 no short-form mapping`
@@ -3843,7 +4066,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     return abilities;
   }
   isEncryptionPermissionEntry(entry) {
-    return entry.service === import_sdk_core6.ENCRYPTION_PERMISSION_SERVICE && entry.path.startsWith("urn:tinycloud:encryption:");
+    return entry.service === import_sdk_core7.ENCRYPTION_PERMISSION_SERVICE && entry.path.startsWith("urn:tinycloud:encryption:");
   }
   permissionsToRawAbilities(entries) {
     const rawAbilities = {};
@@ -3876,11 +4099,11 @@ var _TinyCloudNode = class _TinyCloudNode {
   }
   sessionCoversPermissionEntries(session, entries) {
     try {
-      const granted = (0, import_sdk_core6.parseRecapCapabilities)(
+      const granted = (0, import_sdk_core7.parseRecapCapabilities)(
         (siwe) => this.wasmBindings.parseRecapFromSiwe(siwe),
         session.siwe
       );
-      return (0, import_sdk_core6.isCapabilitySubset)(entries, granted).subset;
+      return (0, import_sdk_core7.isCapabilitySubset)(entries, granted).subset;
     } catch {
       return false;
     }
@@ -4088,7 +4311,23 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (granted.resource !== void 0 || requested.resource !== void 0) {
       return granted.resource !== void 0 && requested.resource !== void 0 && granted.resource === requested.resource && this.pathContains(granted.path, requested.path);
     }
-    return granted.spaceId !== void 0 && requested.spaceId !== void 0 && granted.spaceId === requested.spaceId && this.pathContains(granted.path, requested.path);
+    return granted.spaceId !== void 0 && requested.spaceId !== void 0 && this.spaceIdsEqual(granted.spaceId, requested.spaceId) && this.pathContains(granted.path, requested.path);
+  }
+  // Space IDs are `tinycloud:pkh:eip155:<chain>:<0xADDR>:<name>`. The embedded
+  // EIP-155 address is case-insensitive, but the CLI canonicalizes it to
+  // lowercase when building a space URI while stored runtime delegations keep
+  // the EIP-55 checksummed form — so a byte-for-byte compare spuriously rejects
+  // an otherwise-valid grant. Lowercase ONLY the `eip155:<chain>:0x<addr>`
+  // segment and leave everything else (crucially the case-sensitive space NAME)
+  // byte-exact. Mirrors the CLI's `normalizeSpaceForCompare` (OPENKEY_SCOPE_MISMATCH fix).
+  spaceIdsEqual(a, b) {
+    return this.normalizeSpaceAddress(a) === this.normalizeSpaceAddress(b);
+  }
+  normalizeSpaceAddress(space) {
+    return space.replace(
+      /(eip155:\d+:)(0x[0-9a-fA-F]{40})/,
+      (_match, prefix, addr) => prefix + addr.toLowerCase()
+    );
   }
   actionContains(grantedAction, requestedAction) {
     if (grantedAction === requestedAction) {
@@ -4195,7 +4434,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_core6.pkhDid)(address, 1);
+      resolvedDelegateDID = (0, import_sdk_core7.pkhDid)(address, 1);
     }
     const entries = legacyParamsToPermissionEntries(
       params.actions,
@@ -4210,7 +4449,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       );
       return result.delegation;
     } catch (err) {
-      if (err instanceof import_sdk_core6.PermissionNotInManifestError) {
+      if (err instanceof import_sdk_core7.PermissionNotInManifestError) {
       } else {
         throw err;
       }
@@ -4267,7 +4506,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       ...prepared,
       signature
     });
-    const activateResult = await (0, import_sdk_core6.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
       this.config.host,
       delegationSession.delegationHeader
     );
@@ -4289,7 +4528,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_core6.makePublicSpaceId)(
+      const publicSpaceId = (0, import_sdk_core7.makePublicSpaceId)(
         this.wasmBindings.ensureEip55(session.address),
         session.chainId
       );
@@ -4312,7 +4551,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         ...publicPrepared,
         signature: publicSignature
       });
-      const publicActivateResult = await (0, import_sdk_core6.activateSessionWithHost)(
+      const publicActivateResult = await (0, import_sdk_core7.activateSessionWithHost)(
         this.config.host,
         publicSession.delegationHeader
       );
@@ -4352,7 +4591,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     const targetHost = delegation.host ?? this.config.host;
     if (this.isSessionOnly) {
       const myDid = this.did;
-      if (!didPrincipalMatches(delegation.delegateDID, myDid)) {
+      if (!didPrincipalMatches2(delegation.delegateDID, myDid)) {
         throw new Error(
           `Delegation targets ${delegation.delegateDID} but this user's DID is ${myDid}. The delegation must target this user's DID.`
         );
@@ -4417,7 +4656,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       ...prepared,
       signature
     });
-    const activateResult = await (0, import_sdk_core6.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
       targetHost,
       invokerSession.delegationHeader
     );
@@ -4523,7 +4762,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       ...prepared,
       signature
     });
-    const activateResult = await (0, import_sdk_core6.activateSessionWithHost)(
+    const activateResult = await (0, import_sdk_core7.activateSessionWithHost)(
       targetHost,
       subDelegationSession.delegationHeader
     );
@@ -4559,7 +4798,7 @@ _TinyCloudNode.SESSION_EXPIRY_SAFETY_MARGIN_MS = 6e4;
 var TinyCloudNode = _TinyCloudNode;
 
 // src/core.ts
-var import_sdk_core9 = require("@tinycloud/sdk-core");
+var import_sdk_core10 = require("@tinycloud/sdk-core");
 
 // src/delegation.ts
 function serializeDelegation(delegation) {
@@ -4578,7 +4817,6 @@ function deserializeDelegation(data) {
 }
 
 // src/core.ts
-var import_sdk_core10 = require("@tinycloud/sdk-core");
 var import_sdk_core11 = require("@tinycloud/sdk-core");
 var import_sdk_core12 = require("@tinycloud/sdk-core");
 var import_sdk_core13 = require("@tinycloud/sdk-core");
@@ -4587,10 +4825,12 @@ var import_sdk_core15 = require("@tinycloud/sdk-core");
 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");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCOUNT_REGISTRY_PATH,
   ACCOUNT_REGISTRY_SPACE,
+  AccountService,
   AutoApproveSpaceCreationHandler,
   CapabilityKeyRegistry,
   CapabilityKeyRegistryErrorCodes,