@muhkoo/connect 0.10.5-alpha.0 → 0.10.7-alpha.0

package/dist/connect.d.ts

@@ -4146,6 +4146,17 @@ declare class Space {
         data: Uint8Array;
         stat: FileStat;
     }>;
+    /** Declare a file's shards (ref++ + meter) for a manifest already stored —
+     *  used to back-fill accounting for files written before commit existed, or to
+     *  register a manifest received via sharing. `putFile` already commits new
+     *  writes automatically; this is the explicit form. */
+    commitFile(manifest: FileManifest): Promise<void>;
+    /** Release a file's shards (ref--) when the owner deletes or unshares it. At
+     *  zero references a shard enters a retention window, then is GC'd. Idempotent-
+     *  ish: safe to call once per manifest the owner drops. */
+    releaseFile(manifest: FileManifest): Promise<void>;
+    /** Commit/release a manifest's shards with the accelerator (metering + refcount). */
+    private commitShards;
     private fileStorage;
     /** Wire the RAW_FRAME handler that drives fan-out events. */
     private wireFanout;

package/dist/server/index.js

@@ -2976,7 +2976,7 @@ function base64UrlDecode(s) {
  * expect (and isn't serving a stale cached bundle). Keep this in sync with
  * `package.json` `version`.
  */
-const VERSION = "0.10.5-alpha.0";
+const VERSION = "0.10.7-alpha.0";
 
 /**
  * `HttpClient` — the one place the unified {@link Client} talks to the
@@ -7330,12 +7330,53 @@ class Space {
     }
     // -- room-scoped files (no websocket needed) -------------------------------
     async putFile(file, metadata, opts = {}) {
-        return this.fileStorage(opts.backgroundUpload)
+        const result = await this.fileStorage(opts.backgroundUpload)
             .writeFileToShards({ data: file, metadata, onProgress: opts.onProgress });
+        // Declare this manifest's shards to the accelerator: attributes the stored
+        // bytes to the owning app (so storage is never unmetered) and reference-
+        // counts the shards for GC. Public shard hashes only — the per-chunk keys
+        // stay inside the manifest, which the caller keeps in a vault/Space.
+        await this.commitShards(result.manifest, "commit");
+        return result;
     }
     async getFile(manifest) {
         return this.fileStorage().readFileFromShards(manifest);
     }
+    /** Declare a file's shards (ref++ + meter) for a manifest already stored —
+     *  used to back-fill accounting for files written before commit existed, or to
+     *  register a manifest received via sharing. `putFile` already commits new
+     *  writes automatically; this is the explicit form. */
+    async commitFile(manifest) {
+        await this.commitShards(manifest, "commit");
+    }
+    /** Release a file's shards (ref--) when the owner deletes or unshares it. At
+     *  zero references a shard enters a retention window, then is GC'd. Idempotent-
+     *  ish: safe to call once per manifest the owner drops. */
+    async releaseFile(manifest) {
+        await this.commitShards(manifest, "release");
+    }
+    /** Commit/release a manifest's shards with the accelerator (metering + refcount). */
+    async commitShards(manifest, action) {
+        const hashes = manifest.chunks.flatMap((c) => c.shardHashes);
+        if (hashes.length === 0)
+            return;
+        const body = JSON.stringify({ hashes, bytes: manifest.size });
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                const res = await this.deps.fetch(`${this.deps.httpBaseUrl}/api/storage/${action}`, {
+                    method: "POST", headers: { "Content-Type": "application/json" }, body,
+                });
+                if (res.ok)
+                    return;
+            }
+            catch { /* retry */ }
+            await new Promise((r) => setTimeout(r, 400 * (attempt + 1)));
+        }
+        // Best-effort: a missed commit leaves the shards to orphan-GC (still not
+        // durable-unmetered long-term); a missed release just delays GC. Reconciled
+        // by the platform sweep. Don't fail the caller's write on a metering hiccup.
+        console.warn(`[muhkoo] storage ${action} did not confirm for ${hashes.length} shard(s)`);
+    }
     fileStorage(backgroundUpload = false) {
         // Global, content-addressed shard store — same store `client.storage`
         // uses, so a file shared into a channel resolves from anywhere by