@tinycloud/sdk-services 3.7.0-beta.2 → 3.7.0-beta.4

package/dist/index.cjs

@@ -5561,20 +5561,29 @@ var StorageFullMonitor = class {
   /**
    * @param ownerOf Owner key of a space id. Spaces with one key share one
    * storage budget. Defaults to the space id itself.
+   * @param ownOwner Owner key of the signed-in account, or undefined when
+   * there is none. Rejections on that owner's storage, or on a space that was
+   * unknown, start the episode.
    */
-  constructor(ownerOf = (spaceId) => spaceId) {
+  constructor(ownerOf = (spaceId) => spaceId, ownOwner = () => void 0) {
     this.ownerOf = ownerOf;
-    /** First rejection per owner key; {@link UNKNOWN_OWNER} when the space was unknown. */
+    this.ownOwner = ownOwner;
+    /**
+     * First rejection per owner key; {@link UNKNOWN_OWNER} when the space was unknown.
+     * A status read or a successful write removes the owner, so best-effort writes resume.
+     */
     this.full = /* @__PURE__ */ new Map();
     this.handlers = /* @__PURE__ */ new Set();
+    this.episodeListeners = /* @__PURE__ */ new Set();
+    this.delegatedListeners = /* @__PURE__ */ new Set();
   }
-  /** True while any owner's storage is known to be full. */
+  /** True while any owner's storage is known to be full for best-effort writes. */
   get isFull() {
     return this.full.size > 0;
   }
-  /** The rejection `storage.full` announced, until the episode ends. */
+  /** The rejection that started the own-storage episode, until it ends. */
   get rejection() {
-    return this.event;
+    return this.episode?.event;
   }
   /**
    * True when a write to `spaceId`'s owner was rejected, or a write whose
@@ -5583,13 +5592,31 @@ var StorageFullMonitor = class {
   isFullFor(spaceId) {
     return this.full.has(UNKNOWN_OWNER) || spaceId !== void 0 && this.full.has(this.ownerOf(spaceId));
   }
-  /** Watch a context's service errors. Returns the unsubscribe function. */
+  /** Subscribe to the own-storage episode starting or ending. Returns the unsubscribe function. */
+  onEpisode(listener) {
+    this.episodeListeners.add(listener);
+    return () => {
+      this.episodeListeners.delete(listener);
+    };
+  }
+  /**
+   * Subscribe to a delegated owner's storage being found full: once per owner
+   * until that owner is cleared. The own-storage episode does not fire it.
+   * Returns the unsubscribe function.
+   */
+  onDelegated(listener) {
+    this.delegatedListeners.add(listener);
+    return () => {
+      this.delegatedListeners.delete(listener);
+    };
+  }
+  /** Watch a context's service errors and successful writes. Returns the unsubscribe function. */
   observe(context) {
-    return context.on(TelemetryEvents.SERVICE_ERROR, (data) => {
+    const stopErrors = context.on(TelemetryEvents.SERVICE_ERROR, (data) => {
       const { service, error } = data;
       if (!error || !isStorageFullError(error)) return;
       const spaceId = context.session?.spaceId;
-      const owner = spaceId ? this.ownerOf(spaceId) : UNKNOWN_OWNER;
+      const owner = this.ownerFor(spaceId);
       if (this.full.has(owner)) return;
       const meta = error.meta ?? {};
       const event = { service: service ?? error.service, error };
@@ -5600,8 +5627,13 @@ var StorageFullMonitor = class {
       }
       if (spaceId) event.spaceId = spaceId;
       this.full.set(owner, event);
-      if (this.event) return;
-      this.event = event;
+      if (this.isOwn(owner)) {
+        if (this.episode) return;
+        this.episode = { owner, event };
+        this.notifyEpisode();
+      } else {
+        this.notifyDelegated();
+      }
       context.emit(TelemetryEvents.STORAGE_FULL, event);
       for (const handler of this.handlers) {
         try {
@@ -5611,6 +5643,19 @@ var StorageFullMonitor = class {
         }
       }
     });
+    const stopWrites = context.on(TelemetryEvents.SERVICE_RESPONSE, (data) => {
+      const { service, action, ok: ok2 } = data;
+      if (ok2 !== true || !isCommittingWrite(service, action)) return;
+      const owner = this.ownerFor(context.session?.spaceId);
+      this.full.delete(owner);
+      if (this.episode?.owner !== owner) return;
+      this.episode = void 0;
+      this.notifyEpisode();
+    });
+    return () => {
+      stopErrors();
+      stopWrites();
+    };
   }
   /** Subscribe to the `storage.full` event. Returns the unsubscribe function. */
   on(handler) {
@@ -5619,22 +5664,56 @@ var StorageFullMonitor = class {
       this.handlers.delete(handler);
     };
   }
-  /** Forget that any owner's storage is full; the next rejection emits `storage.full` again. */
+  /** Forget every owner's full state and end the episode; the next rejection starts a new one. */
   clear() {
     this.full.clear();
-    this.event = void 0;
+    if (!this.episode) return;
+    this.episode = void 0;
+    this.notifyEpisode();
   }
   /**
-   * Forget that `spaceId`'s owner is full (`undefined`: the rejections whose
-   * space was unknown). Once no owner is full, the next rejection emits
-   * `storage.full` again.
+   * Forget that `spaceId`'s owner is full for best-effort writes (`undefined`:
+   * the rejections whose space was unknown). Does not end the episode.
    */
   clearFor(spaceId) {
-    this.full.delete(spaceId === void 0 ? UNKNOWN_OWNER : this.ownerOf(spaceId));
-    if (this.full.size === 0) this.event = void 0;
+    this.full.delete(this.ownerFor(spaceId));
+  }
+  isOwn(owner) {
+    return owner === UNKNOWN_OWNER || owner === this.ownOwner();
+  }
+  ownerFor(spaceId) {
+    return spaceId ? this.ownerOf(spaceId) : UNKNOWN_OWNER;
+  }
+  notifyEpisode() {
+    for (const listener of this.episodeListeners) {
+      try {
+        listener();
+      } catch (listenerError) {
+        console.error("Error in storage episode listener:", listenerError);
+      }
+    }
+  }
+  notifyDelegated() {
+    for (const listener of this.delegatedListeners) {
+      try {
+        listener();
+      } catch (listenerError) {
+        console.error("Error in delegated storage listener:", listenerError);
+      }
+    }
   }
 };
 var UNKNOWN_OWNER = "\0unknown";
+var COMMITTING_ACTIONS = /* @__PURE__ */ new Map([
+  ["kv", ["put", "batchPut"]],
+  ["vault", ["put"]],
+  ["sql", ["execute", "batch", "executeStatement", "migrations.apply"]],
+  ["duckdb", ["execute", "batch", "executeStatement", "import"]]
+]);
+function isCommittingWrite(service, action) {
+  if (service === void 0 || action === void 0) return false;
+  return COMMITTING_ACTIONS.get(service)?.includes(action) ?? false;
+}
 
 // src/storage/status.ts
 var STORAGE_MANAGE_URL = "https://account.tinycloud.xyz/storage";