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

package/dist/{core-DiVEwp2P.d.cts → core--mjBU9Jq.d.cts}

@@ -332,8 +332,31 @@ declare class NodeUserAuthorization implements IUserAuthorization {
      * `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: TinyCloudSession, hosts?: string[]): void;
+    /**
+     * 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.
      */
-    setRestoredTinyCloudSession(session: TinyCloudSession): void;
+    ensureTinyCloudHosts(): Promise<void>;
     private resolveTinyCloudHostsForSignIn;
     private requireTinyCloudHosts;
     private get primaryTinyCloudHost();
@@ -1067,7 +1090,32 @@ declare class TinyCloudNode {
          * for callers that need to round-trip the full session shape.
          */
         signature?: string;
+        /**
+         * The TinyCloud hosts this session was created against (from
+         * {@link PersistedSessionData.tinycloudHosts}). When present they are
+         * adopted so the restored session targets the same node as the
+         * original sign-in — without this, service calls fall back to the
+         * default host and the auth layer throws "TinyCloud hosts have not
+         * been resolved". When absent (old persisted session) hosts resolve
+         * lazily via the registry/fallback on the first host-needing call.
+         */
+        tinycloudHosts?: string[];
     }): Promise<void>;
+    /**
+     * 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.
+     */
+    private resolveRestoredHost;
     /**
      * Resolve the currently-active TinyCloudSession, preferring the auth
      * layer's value (wallet mode) and falling back to the node-level

package/dist/{core-DiVEwp2P.d.ts → core--mjBU9Jq.d.ts}

@@ -332,8 +332,31 @@ declare class NodeUserAuthorization implements IUserAuthorization {
      * `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: TinyCloudSession, hosts?: string[]): void;
+    /**
+     * 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.
      */
-    setRestoredTinyCloudSession(session: TinyCloudSession): void;
+    ensureTinyCloudHosts(): Promise<void>;
     private resolveTinyCloudHostsForSignIn;
     private requireTinyCloudHosts;
     private get primaryTinyCloudHost();
@@ -1067,7 +1090,32 @@ declare class TinyCloudNode {
          * for callers that need to round-trip the full session shape.
          */
         signature?: string;
+        /**
+         * The TinyCloud hosts this session was created against (from
+         * {@link PersistedSessionData.tinycloudHosts}). When present they are
+         * adopted so the restored session targets the same node as the
+         * original sign-in — without this, service calls fall back to the
+         * default host and the auth layer throws "TinyCloud hosts have not
+         * been resolved". When absent (old persisted session) hosts resolve
+         * lazily via the registry/fallback on the first host-needing call.
+         */
+        tinycloudHosts?: string[];
     }): Promise<void>;
+    /**
+     * 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.
+     */
+    private resolveRestoredHost;
     /**
      * Resolve the currently-active TinyCloudSession, preferring the auth
      * layer's value (wallet mode) and falling back to the node-level

package/dist/core.cjs

@@ -455,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) {
@@ -657,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);
@@ -699,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)(
@@ -880,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;
@@ -1047,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;
@@ -2178,6 +2218,14 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (sessionData.chainId) {
       this._chainId = sessionData.chainId;
     }
+    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,
@@ -2223,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