@muhkoo/connect 0.15.0-alpha.0 → 0.15.0-alpha.1

package/dist/browser/index.js

@@ -6675,7 +6675,7 @@ async function parseOrThrow(response, op) {
  * expect (and isn't serving a stale cached bundle). Keep this in sync with
  * `package.json` `version`.
  */
-const VERSION = "0.15.0-alpha.0";
+const VERSION = "0.15.0-alpha.1";
 
 /**
  * `HttpClient` — the one place the unified {@link Client} talks to the
@@ -15458,6 +15458,18 @@ class VfsNamespace {
      * than by TTL — a stale directory listing shows files that are not there.
      */
     cache = new Map();
+    /**
+     * The write of each directory record still in flight, by id.
+     *
+     * Two writes of one record must land in the order they were made. The
+     * personal space has no compare-and-swap: of two writes of one key that
+     * are in flight together it keeps whichever request finishes last, and
+     * that is often the one sent first. Then the earlier write, sealed before
+     * the later edit was made, undoes it. That is how a file deleted forever
+     * from the Trash, while the move that put it there was still being
+     * written, came back. So each write waits for the one before it.
+     */
+    writing = new Map();
     historyLimit;
     maxEntries;
     maxPathChars;
@@ -15921,10 +15933,7 @@ class VfsNamespace {
         const parentPath = dirname(target);
         await this.mkdir(parentPath, { recursive: true });
         const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
-        const { manifest, size } = await this.deps.content.write(bytes, {
-            name,
-            type: opts.type ?? contentTypeFor(name),
-        });
+        const { manifest, size } = await this.deps.content.write(bytes, { name, type: opts.type ?? contentTypeFor(name) }, { onProgress: opts.onProgress });
         const parent = await this.openDir(parentPath);
         const prior = entryIn(parent.node, name);
         if (prior?.kind === "dir")
@@ -16482,24 +16491,14 @@ class VfsNamespace {
             if (Object.hasOwn(dir.node.entries, name))
                 delete dir.hidden[name];
         }
-        const stored = Object.keys(dir.hidden).length
-            ? { ...dir.node, entries: Object.assign(Object.create(null), dir.hidden, dir.node.entries) }
-            : dir.node;
+        // Not sent until any earlier write of this record has landed: see
+        // `writing`. Whether that one worked or not, this one still goes.
+        const before = this.writing.get(dir.id);
+        const send = () => this.writeRecord(dir);
+        const write = before ? before.then(send, send) : send();
+        this.writing.set(dir.id, write);
         try {
-            let sealed;
-            try {
-                sealed = await seal(dir.key, stored);
-            }
-            catch (err) {
-                // JSON.stringify's own failures: a value too deeply nested to
-                // write. Reading drops those from a stored record, so this is
-                // what the write itself was given.
-                if (!(err instanceof RangeError || err instanceof TypeError))
-                    throw err;
-                const where = dir.path ?? `the directory stored as record ${printable(dir.id, 40)}`;
-                throw new VfsConflictError(`cannot write to ${where}: it would hold a value nested too deeply to store`);
-            }
-            await this.deps.store.put(dirKey(dir.id), sealed);
+            await write;
         }
         catch (err) {
             // The edit above was made in place, on the very object the cache
@@ -16510,8 +16509,38 @@ class VfsNamespace {
             this.cache.delete(dir.id);
             throw err;
         }
+        finally {
+            if (this.writing.get(dir.id) === write)
+                this.writing.delete(dir.id);
+        }
         this.cache.set(dir.id, Promise.resolve(dir));
     }
+    /**
+     * Seal a directory record as it stands NOW and put it in the store.
+     *
+     * Read at the moment of sending, not when the edit was made, so a write
+     * that waited behind another carries every edit made to the record by
+     * then, its own included.
+     */
+    async writeRecord(dir) {
+        const stored = Object.keys(dir.hidden).length
+            ? { ...dir.node, entries: Object.assign(Object.create(null), dir.hidden, dir.node.entries) }
+            : dir.node;
+        let sealed;
+        try {
+            sealed = await seal(dir.key, stored);
+        }
+        catch (err) {
+            // JSON.stringify's own failures: a value too deeply nested to
+            // write. Reading drops those from a stored record, so this is
+            // what the write itself was given.
+            if (!(err instanceof RangeError || err instanceof TypeError))
+                throw err;
+            const where = dir.path ?? `the directory stored as record ${printable(dir.id, 40)}`;
+            throw new VfsConflictError(`cannot write to ${where}: it would hold a value nested too deeply to store`);
+        }
+        await this.deps.store.put(dirKey(dir.id), sealed);
+    }
     async createDir(parentPath, name) {
         assertValidName(name);
         const parent = await this.openDir(parentPath);
@@ -19488,9 +19517,9 @@ class Client {
                 // GC. `storage.writeFile` would additionally index the manifest
                 // in the space — a second, diverging source of truth for a file
                 // whose handle the VFS already holds.
-                write: async (data, meta) => {
+                write: async (data, meta, opts) => {
                     const space = await resolveContentSpace();
-                    const { manifest, stat } = await space.putFile(data, { name: meta.name, type: meta.type });
+                    const { manifest, stat } = await space.putFile(data, { name: meta.name, type: meta.type }, { onProgress: opts?.onProgress });
                     return { manifest, size: stat.size };
                 },
                 // Reads go through the manifest alone — no space needed. That is