@tinycloud/node-sdk 2.4.0-beta.15 → 2.4.0-beta.17

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

@@ -1047,15 +1047,44 @@ declare class TinyCloudNode {
      * 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}.
+     * (`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.
      */
     ensureOwnedSpaceHosted(name: string): Promise<string>;
+    /**
+     * 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".
+     */
+    private isOwnedSpaceRegistered;
     /**
      * Restore a previously established session from stored delegation data.
      *

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

@@ -1047,15 +1047,44 @@ declare class TinyCloudNode {
      * 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}.
+     * (`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.
      */
     ensureOwnedSpaceHosted(name: string): Promise<string>;
+    /**
+     * 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".
+     */
+    private isOwnedSpaceRegistered;
     /**
      * Restore a previously established session from stored delegation data.
      *

package/dist/core.cjs

@@ -2027,6 +2027,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) {
@@ -2178,16 +2179,78 @@ var _TinyCloudNode = class _TinyCloudNode {
    * 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}.
+   * (`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) {
-    return this.hostOwnedSpace(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.