@hydranium/protocol 1.0.0-next.268 → 1.0.0-next.269

package/lib/client/data-session.js

@@ -14,6 +14,7 @@ const clock_1 = require("../clock");
 const errors_1 = require("../errors");
 const base_version_1 = require("../model-service/base-version");
 const primitives_1 = require("../messages/primitives");
+const noop_logger_1 = require("../noop-logger");
 const random_uuid_1 = require("../random-uuid");
 /**
  * A session could not re-open a document it had open after its connection
@@ -91,17 +92,17 @@ class DataSession {
     /** URIs this session has open, re-opened after a reconnect. */
     openUris = new Set();
     /**
-     * Per URI in {@link openUris}, the URI the server's last answer to its open
-     * or re-open named. The server keys its notifications by it, and so does
-     * the host's record of what its client was told.
+     * Per URI in {@link openUris}, or whose open answered and whose watch is
+     * still under way, the open it is under. A repeat open keeps it, as the
+     * server keeps its earlier open.
      */
-    serverUris = new Map();
+    opens = new Map();
     /**
-     * Per URI, how many opens of it this session has under way. Such a URI
-     * counts as open for {@link withOpenDocument}, which would otherwise close
-     * it under the open that is still being made.
+     * Per URI, the opens of it this session has under way. Such a URI counts
+     * as open for {@link withOpenDocument}, which would otherwise close it
+     * under the open that is still being made.
      */
-    openingUris = new Map();
+    openings = new Map();
     /** Per URI written since its last save, what {@link restore} needs to write it again. */
     unsavedWrites = new Map();
     /**
@@ -118,6 +119,13 @@ class DataSession {
      * version of a write still in flight as well, and that write is not saved.
      */
     savedVersions = new Map();
+    /**
+     * URIs this session created whose whole text is still its own and unsaved,
+     * even with no write recorded: no save, clean flip, other client's write or
+     * reported loss has come since the create answered; see
+     * {@link forgetGoneDocument}.
+     */
+    createdUris = new Set();
     /** Per URI, this session's calls still in flight on it, which a close waits for. */
     inFlight = new Map();
     /** This session's saves still in flight, which a host's exit waits for; see {@link hasSavesInFlight}. */
@@ -156,12 +164,18 @@ class DataSession {
     dirtySubscription;
     /** The subscription to the host's `onDidUpdateDocument`, disposed with the session. */
     updateSubscription;
+    /** The subscription to the host's `onDidDeleteDocument`, disposed with the session. */
+    deletionSubscription;
+    /** The host's logger, or one that logs nothing. */
+    logger;
     constructor(clientId, host, label) {
         this.clientId = clientId;
         this.host = host;
         this.label = label;
+        this.logger = host.logger ?? new noop_logger_1.NoopLogger();
         this.dirtySubscription = host.onDidChangeDirty?.(event => this.forgetSavedWrite(event));
         this.updateSubscription = host.onDidUpdateDocument?.(event => this.forgetSupersededWrite(event));
+        this.deletionSubscription = host.onDidDeleteDocument?.(event => this.forgetDeletedDocument(event));
     }
     /**
      * The connected, READY server proxy once this session is registered on it,
@@ -207,10 +221,7 @@ class DataSession {
      * from `getModelDocument({ includeDiagnostics: true })`.
      */
     openDocument(args) {
-        return this.trackOpen(args.uri, async () => {
-            const server = await this.connected();
-            return this.watchOpened(server, args.uri, await server.openModelDocument({ ...args, clientId: this.clientId }));
-        });
+        return this.trackOpen(args.uri, opening => this.openAndWatch(args.uri, opening, false, server => server.openModelDocument({ ...args, clientId: this.clientId })));
     }
     /**
      * Create a document that exists nowhere yet, open and watched for this
@@ -218,26 +229,64 @@ class DataSession {
      * refuses a URI that exists on disk or that any client has open.
      */
     createDocument(args) {
-        return this.trackOpen(args.uri, async () => {
+        return this.trackOpen(args.uri, opening => this.openAndWatch(args.uri, opening, true, server => server.createModelDocument({ ...args, clientId: this.clientId })));
+    }
+    /**
+     * Send `open` and watch what it answered, again for as long as a deletion
+     * heard while the watch is under way closes that open: sent after the
+     * deletion, the open fails as an open of a gone file does, or opens the
+     * file that is back. `created` marks the document in {@link createdUris}
+     * once the open answers, before the watch, so an event that clears the mark
+     * meanwhile clears it for good.
+     *
+     * An `opening` a close marked answers with the document, recording nothing
+     * and sending nothing again; one it marked before the open answered is
+     * undone, since the server may have taken the close first. A failed watch
+     * is undone too: the caller sees a failed open, and so would never close it.
+     */
+    async openAndWatch(uri, opening, created, open) {
+        for (;;) {
             const server = await this.connected();
-            return this.watchOpened(server, args.uri, await server.createModelDocument({ ...args, clientId: this.clientId }));
-        });
+            const document = await open(server);
+            if (opening.closed) {
+                await this.undoOpen(server, uri, opening);
+                return document;
+            }
+            if (created) {
+                this.createdUris.add(uri);
+            }
+            let watched;
+            try {
+                watched = await this.watchOpened(server, uri, document);
+            }
+            catch (error) {
+                await this.undoOpen(server, uri, opening);
+                throw error;
+            }
+            if (watched || opening.closed) {
+                return watched ?? document;
+            }
+        }
     }
     /**
-     * Watch a document this session just opened, and record it as open. A
-     * failed watch closes it again: the caller sees a failed open and so would
-     * never close it.
+     * Watch a document this session just opened, and record it as open.
+     * Answers `undefined`, recording nothing, when a deletion heard while the
+     * watch is under way has ended the open already, and the document,
+     * recording nothing, when a close has. A failed watch rejects with the open
+     * still recorded, for its caller to undo, see {@link undoOpen}.
      */
     async watchOpened(server, uri, document) {
-        try {
-            await server.watchModelDocument({ uri, clientId: this.clientId });
-        }
-        catch (error) {
-            await server.closeModelDocument({ uri, clientId: this.clientId }).catch(() => undefined);
-            throw error;
+        // Recorded before the watch, so a deletion heard while it is under way
+        // finds this open, which the server made before the deletion.
+        const open = this.opens.get(uri) ?? { serverUri: document.uri, deleted: false };
+        this.opens.set(uri, open);
+        await server.watchModelDocument({ uri, clientId: this.clientId });
+        if (this.opens.get(uri) !== open) {
+            // Sent again, it ends as an open sent after the deletion would; a
+            // close is the caller's later call, and stands.
+            return open.deleted ? undefined : document;
         }
         this.openUris.add(uri);
-        this.serverUris.set(uri, document.uri);
         this.recordText(uri, document);
         // Keyed as the server keys its notifications, which may not be how the
         // caller spelled the URI.
@@ -253,18 +302,49 @@ class DataSession {
         this.assertLive();
         await this.settle(this.inFlight.get(args.uri));
         // Forgotten before the close is sent, so a reconnect in between does not
-        // re-open a document the caller has closed; after the wait, so an open
-        // of it that was still in flight does not record it again.
-        const serverUri = this.serverUris.get(args.uri) ?? args.uri;
-        this.openUris.delete(args.uri);
-        this.serverUris.delete(args.uri);
-        this.unsavedWrites.delete(args.uri);
-        this.lastAnswers.delete(args.uri);
-        this.savedVersions.delete(args.uri);
-        this.host.forgetDirty?.(serverUri);
+        // re-open a document the caller has closed. Every open of it under way
+        // by now is marked, even one called after this close, so it neither
+        // records it again nor is sent again.
+        this.openings.get(args.uri)?.forEach(opening => {
+            opening.closed = true;
+        });
+        this.forgetDocument(args.uri);
         const server = await this.connected();
         await server.closeModelDocument({ ...args, clientId: this.clientId });
     }
+    /**
+     * Close `uri` again after `opening` failed or was closed while under way,
+     * and drop what it recorded, unless the session still relies on the open,
+     * see {@link hasOpen}: the server holds one open per session and URI, so
+     * the close would end that one too.
+     */
+    async undoOpen(server, uri, opening) {
+        if (this.hasOpen(uri, opening)) {
+            return;
+        }
+        this.opens.delete(uri);
+        this.createdUris.delete(uri);
+        await server.closeModelDocument({ uri, clientId: this.clientId }).catch(() => undefined);
+    }
+    /** Drop everything this session keeps of `uri`, which it no longer has open. */
+    forgetDocument(uri) {
+        const serverUri = this.opens.get(uri)?.serverUri ?? uri;
+        this.openUris.delete(uri);
+        this.opens.delete(uri);
+        this.unsavedWrites.delete(uri);
+        this.lastAnswers.delete(uri);
+        this.savedVersions.delete(uri);
+        this.createdUris.delete(uri);
+        this.host.forgetDirty?.(serverUri);
+    }
+    /**
+     * Whether this session has `uri` open, or has an open of it under way that
+     * no close has marked, other than `except`. A marked open records nothing,
+     * so nothing can rely on it.
+     */
+    hasOpen(uri, except) {
+        return this.openUris.has(uri) || [...(this.openings.get(uri) ?? [])].some(opening => opening !== except && !opening.closed);
+    }
     /**
      * Open `args.uri`, run `fn` with the opened snapshot, and close it once
      * `fn` settles, whether it returned or threw. A URI this session already
@@ -272,7 +352,7 @@ class DataSession {
      * undoes only the open this call made.
      */
     async withOpenDocument(args, fn) {
-        const alreadyOpen = this.openUris.has(args.uri) || this.openingUris.has(args.uri);
+        const alreadyOpen = this.hasOpen(args.uri);
         const document = await this.openDocument(args);
         try {
             return await fn(document);
@@ -289,8 +369,9 @@ class DataSession {
             const server = await this.connected();
             const update = { ...args };
             const baseHash = await this.baseHashOf(server, args.uri, args.baseVersion);
+            const open = this.opens.get(args.uri);
             const document = await server.updateModelDocument({ ...args, clientId: this.clientId });
-            this.recordWrite(args.uri, document, baseHash, { update });
+            this.recordWrite(args.uri, open, document, baseHash, { update });
             return document;
         });
     }
@@ -306,8 +387,9 @@ class DataSession {
             const updates = { ...args, updates: args.updates.map(update => ({ ...update })) };
             const server = await this.connected();
             const baseHashes = await Promise.all(args.updates.map(update => this.baseHashOf(server, update.uri, update.baseVersion)));
+            const opens = args.updates.map(update => this.opens.get(update.uri));
             const documents = await server.updateModelDocuments({ ...args, clientId: this.clientId });
-            args.updates.forEach((update, index) => this.recordWrite(update.uri, documents[index], baseHashes[index], { updates, index }));
+            args.updates.forEach((update, index) => this.recordWrite(update.uri, opens[index], documents[index], baseHashes[index], { updates, index }));
             return documents;
         });
     }
@@ -326,7 +408,13 @@ class DataSession {
     trackSave(uri, send) {
         const saving = this.track([uri], async () => {
             const server = await this.connected();
+            const open = this.opens.get(uri);
             const document = await send(server);
+            // Sent under no open, or under one a close or deletion has ended
+            // since: recorded, it would outlive that open.
+            if (!open || this.opens.get(uri) !== open) {
+                return document;
+            }
             // Kept only when its last answer is newer than the text written. Kept
             // whenever it changed while the save ran, a record the save covered
             // survives, and a restore then reports it lost.
@@ -335,6 +423,7 @@ class DataSession {
                 this.unsavedWrites.delete(uri);
             }
             this.recordText(uri, document);
+            this.createdUris.delete(uri);
             // The higher of two saves' answers, which may arrive out of order.
             const saved = this.savedVersions.get(uri);
             if (saved === undefined || document.persisted.version > saved) {
@@ -420,23 +509,25 @@ class DataSession {
     detach() {
         this.detached = true;
         this.openUris.clear();
-        this.serverUris.clear();
+        this.opens.clear();
         this.unsavedWrites.clear();
         this.lastAnswers.clear();
         this.savedVersions.clear();
+        this.createdUris.clear();
         if (!this.disposed) {
             this.disposed = true;
             this.fireDispose();
         }
     }
     /**
-     * Dispose {@link dirtySubscription} and {@link updateSubscription}, fire
-     * {@link onDidDispose} and dispose its emitter, so a second call fires
-     * nothing.
+     * Dispose {@link dirtySubscription}, {@link updateSubscription} and
+     * {@link deletionSubscription}, fire {@link onDidDispose} and dispose its
+     * emitter, so a second call fires nothing.
      */
     fireDispose() {
         this.dirtySubscription?.dispose();
         this.updateSubscription?.dispose();
+        this.deletionSubscription?.dispose();
         this.disposeEmitter.fire(undefined);
         this.disposeEmitter.dispose();
     }
@@ -454,9 +545,10 @@ class DataSession {
     }
     /**
      * Drop the record in {@link unsavedWrites} of a document this session has
-     * open once the server says it turned clean: it holds no unsaved text
-     * then, and a record kept would have a restore report the write lost once
-     * another client's save changed the file.
+     * open once the server says it turned clean, and its mark in
+     * {@link createdUris}: it holds no unsaved text then, and a record kept
+     * would have a restore report the write lost once another client's save
+     * changed the file.
      *
      * The server sends a flip only for a document someone watches, so a
      * document the session writes without watching it keeps its record, and
@@ -468,9 +560,10 @@ class DataSession {
         }
         // The flip names the server's key, which is not always the caller's
         // spelling that the records are kept under.
-        for (const [uri, serverUri] of this.serverUris) {
-            if (serverUri === event.uri) {
+        for (const [uri, open] of this.opens) {
+            if (open.serverUri === event.uri) {
                 this.unsavedWrites.delete(uri);
+                this.createdUris.delete(uri);
             }
         }
     }
@@ -488,18 +581,61 @@ class DataSession {
      * `'rebuilt'` event carries no new text. Like {@link forgetSavedWrite}, it
      * depends on the server sending the event, which it does only for a
      * document someone watches.
+     *
+     * The mark in {@link createdUris} goes on any such event: the unsaved text
+     * is then the other client's, and a record still kept reports the
+     * session's own.
      */
     forgetSupersededWrite(event) {
         if (event.reason !== 'changed' || this.isOwnEcho(event.sourceClientId)) {
             return;
         }
-        for (const [uri, serverUri] of this.serverUris) {
+        for (const [uri, open] of this.opens) {
+            if (open.serverUri !== event.document.uri) {
+                continue;
+            }
+            this.createdUris.delete(uri);
             const write = this.unsavedWrites.get(uri);
-            if (serverUri === event.document.uri && write && this.restoreOutcome(write, event.document) !== 'kept') {
+            if (write && this.restoreOutcome(write, event.document) !== 'kept') {
                 this.unsavedWrites.delete(uri);
             }
         }
     }
+    /**
+     * Forget a document whose file was deleted, which closed this session's
+     * open. At once rather than after the calls in flight settle, which would
+     * let a restore re-open the file that is gone. Unwatched rather than
+     * closed: the server keeps the watch, and a close could end a re-open of a
+     * re-created file still in flight. Unsaved writes are logged, not
+     * reported: the client hears the deletion too.
+     */
+    forgetDeletedDocument(event) {
+        for (const [uri, open] of this.opens) {
+            if (open.serverUri !== event.uri) {
+                continue;
+            }
+            open.deleted = true;
+            this.forgetGoneDocument(uri);
+            this.connected()
+                .then(server => server.unwatchModelDocument({ uri, clientId: this.clientId }))
+                .catch(() => undefined);
+        }
+    }
+    /**
+     * {@link forgetDocument} a document that is gone, logging any unsaved text
+     * it drops, written or created; returns whether it dropped some.
+     */
+    forgetGoneDocument(uri) {
+        const unsaved = this.unsavedWrites.has(uri) || this.createdUris.has(uri);
+        if (unsaved) {
+            this.logger.withUri(uri).warn('Dropped unsaved text: the document is gone');
+        }
+        else {
+            this.logger.withUri(uri).debug('Forgot the document: it is gone');
+        }
+        this.forgetDocument(uri);
+        return unsaved;
+    }
     /**
      * Register on `server`, and after a reconnect restore what the ended session
      * had. Calls issued meanwhile wait for this.
@@ -537,7 +673,11 @@ class DataSession {
      * dropped, and one per document that could not be re-opened or written
      * again for another reason than a conflict. A document that could not be
      * re-opened is forgotten; a failed write keeps its record, for the next
-     * restore to decide again.
+     * restore to decide again. A document closed while the restore runs, or
+     * whose file is deleted then, is neither restored nor reported. One gone
+     * while the connection was down, which the server reads back without a
+     * model, is forgotten, and goes into the report of lost unsaved text when
+     * the session wrote it since its last save, or created it and never saved it.
      *
      * Each document's dirty state goes to the host too, read once the watch is
      * in place and any write is sent: a flip while the connection was down, or
@@ -551,22 +691,63 @@ class DataSession {
         // server numbers afresh, below the versions saved before it.
         this.savedVersions.clear();
         const reopened = new Map();
+        const lost = [];
         for (const uri of [...this.openUris]) {
+            // Closed, or its file deleted, while the restore ran.
+            if (!this.openUris.has(uri)) {
+                continue;
+            }
             try {
                 const document = await server.openModelDocument({ uri, clientId: this.clientId });
-                await server.watchModelDocument({ uri, clientId: this.clientId });
+                if (!this.openUris.has(uri)) {
+                    // Forgotten while it re-opened. A close of the caller's would
+                    // follow, but a deletion sends none.
+                    await server.closeModelDocument({ uri, clientId: this.clientId }).catch(() => undefined);
+                    continue;
+                }
+                // Recorded before the watch, so a deletion heard while it is under
+                // way finds the re-open under the URI it answered with, which a
+                // restarted server may key differently.
+                this.opens.set(uri, { serverUri: document.uri, deleted: false });
+                await server.watchModelDocument({ uri, clientId: this.clientId }).catch(async (error) => {
+                    // Closed, or the server holds the re-open until the session
+                    // ends; no other call relies on it while the restore runs.
+                    await server.closeModelDocument({ uri, clientId: this.clientId }).catch(() => undefined);
+                    throw error;
+                });
                 if (this.openUris.has(uri)) {
-                    this.serverUris.set(uri, document.uri);
                     this.recordText(uri, document);
                 }
                 reopened.set(uri, document);
             }
             catch (error) {
+                // Gone while the connection was down, which no deletion told the
+                // session of: the server answers a read of it without a model.
+                const read = await server.getModelDocument({ uri }).catch(() => undefined);
+                // Forgotten meanwhile, so nothing is lost.
+                if (!this.openUris.has(uri)) {
+                    continue;
+                }
+                if (read && !read.model) {
+                    // No deletion reached the client either, so unsaved text the
+                    // document took with it is reported, as a drop's other losses are.
+                    const write = this.unsavedWrites.get(uri);
+                    if (this.forgetGoneDocument(uri)) {
+                        lost.push(uri);
+                    }
+                    // Kept for `reapply`, where it blocks its set as a document
+                    // that could not be re-opened does, and goes.
+                    if (write) {
+                        this.unsavedWrites.set(uri, write);
+                    }
+                    continue;
+                }
                 // Its record goes with its set's, in `reapply`, which it blocks.
                 this.openUris.delete(uri);
-                this.serverUris.delete(uri);
+                this.opens.delete(uri);
                 this.lastAnswers.delete(uri);
                 this.savedVersions.delete(uri);
+                this.createdUris.delete(uri);
                 this.host.reportError?.(error, (0, primitives_1.resolve)(exports.DATA_SESSION_RESTORE_FAILED, { uri, detail: (0, primitives_1.describeError)(error) }));
             }
         }
@@ -575,7 +756,6 @@ class DataSession {
             const call = 'update' in write.call ? write.call.update : write.call.updates;
             sets.set(call, [...(sets.get(call) ?? []), [uri, write]]);
         }
-        const lost = [];
         for (const members of sets.values()) {
             lost.push(...(await this.reapply(server, members, reopened)));
         }
@@ -586,7 +766,15 @@ class DataSession {
             // A failed read, or one without text, leaves the client's dirty
             // state as it was; the document is restored all the same.
             const current = await server.getModelDocument({ uri }).catch(() => undefined);
-            if (current?.text !== undefined) {
+            // Again after the read: one closed or deleted meanwhile has no
+            // state to tell.
+            if (current?.text !== undefined && this.openUris.has(uri)) {
+                // A created document reads clean only once a save gave it a
+                // baseline, so its text is no longer unsaved. A write record
+                // stays: a reverted document reads clean too, its write unsent.
+                if (!current.text.dirty) {
+                    this.createdUris.delete(uri);
+                }
                 try {
                     this.host.restoreDirty?.({ uri: current.uri, text: current.text });
                 }
@@ -645,10 +833,14 @@ class DataSession {
             }
         }
         // A document that could not be re-opened is forgotten, and was reported
-        // as such.
+        // as such; one closed, saved or deleted while a write ran lost nothing.
         const lose = () => {
-            outcomes.filter(member => member.outcome !== 'kept').forEach(member => this.unsavedWrites.delete(member.uri));
-            return outcomes.filter(member => member.outcome === 'lost' || member.outcome === 'resend').map(member => member.uri);
+            const gone = outcomes.filter(member => member.outcome !== 'kept' && current(member.uri, member.write));
+            gone.forEach(member => {
+                this.unsavedWrites.delete(member.uri);
+                this.createdUris.delete(member.uri);
+            });
+            return gone.filter(member => member.outcome === 'lost' || member.outcome === 'resend').map(member => member.uri);
         };
         if (outcomes.some(member => member.outcome === 'lost' || member.outcome === 'failed')) {
             return lose();
@@ -660,6 +852,7 @@ class DataSession {
         if (resend.length === 0) {
             return [];
         }
+        const opens = resend.map(member => this.opens.get(member.uri));
         let documents;
         try {
             const { call } = resend[0].write;
@@ -683,13 +876,15 @@ class DataSession {
                 return lose();
             }
             for (const { uri, write, baseVersion } of resend) {
+                // Closed, saved or deleted while the write ran: nothing to restore.
+                if (!current(uri, write)) {
+                    continue;
+                }
                 this.host.reportError?.(error, (0, primitives_1.resolve)(exports.DATA_SESSION_RESTORE_FAILED, { uri, detail: (0, primitives_1.describeError)(error) }));
                 // Kept for the next restore, and numbered from the re-opened
                 // version, as the kept records are: a record numbered by a server
                 // that has since restarted would have later answers ignored.
-                if (current(uri, write)) {
-                    this.unsavedWrites.set(uri, { ...write, answer: { ...write.answer, version: baseVersion } });
-                }
+                this.unsavedWrites.set(uri, { ...write, answer: { ...write.answer, version: baseVersion } });
             }
             return [];
         }
@@ -698,7 +893,7 @@ class DataSession {
                 // Recorded afresh, since the answer of a restarted server may be
                 // numbered below the one it replaces.
                 this.unsavedWrites.delete(member.uri);
-                this.recordWrite(member.uri, documents[index], member.write.baseHash, member.write.call);
+                this.recordWrite(member.uri, opens[index], documents[index], member.write.baseHash, member.write.call);
             }
         });
         return [];
@@ -725,17 +920,22 @@ class DataSession {
         return read?.text?.version === baseVersion ? read.text.hash : undefined;
     }
     /**
-     * Record `document` as the answer to a write of `uri`, keeping the base of
-     * the URI's record if it has one. An answer numbered below the record's is
-     * ignored: two writes of `uri` in flight at once may answer out of order,
-     * and the record holds the one applied last.
+     * Record `document` as the answer to a write of `uri` sent under `open`,
+     * keeping the base of the URI's record if it has one. An answer sent under
+     * no open, or under one that has ended, is ignored. So is one numbered below
+     * the record's: two writes of `uri` in flight at once may answer out of
+     * order, and the record holds the one applied last.
      *
      * So is one numbered at or below the URI's entry in {@link savedVersions}.
      * The save came after that write was applied, so the save persisted its
      * text or a later write replaced it, and its answer carries the text as it
      * was when sent, which a restore would report as lost.
      */
-    recordWrite(uri, document, baseHash, call) {
+    recordWrite(uri, open, document, baseHash, call) {
+        // Recorded, it would outlive that open.
+        if (!open || this.opens.get(uri) !== open) {
+            return;
+        }
         const answer = this.answerOf(uri, document);
         const kept = this.unsavedWrites.get(uri);
         if (kept && answer.version < kept.answer.version) {
@@ -780,19 +980,18 @@ class DataSession {
         running.then(done, done);
         return running;
     }
-    /** {@link track} an open of `uri`, counted in {@link openingUris} until it settles. */
+    /** {@link track} an open of `uri`, kept in {@link openings} until it settles. */
     trackOpen(uri, call) {
-        this.openingUris.set(uri, (this.openingUris.get(uri) ?? 0) + 1);
+        const opening = { closed: false };
+        const openings = this.openings.get(uri) ?? new Set();
+        this.openings.set(uri, openings.add(opening));
         const done = () => {
-            const remaining = (this.openingUris.get(uri) ?? 1) - 1;
-            if (remaining > 0) {
-                this.openingUris.set(uri, remaining);
-            }
-            else {
-                this.openingUris.delete(uri);
+            openings.delete(opening);
+            if (openings.size === 0 && this.openings.get(uri) === openings) {
+                this.openings.delete(uri);
             }
         };
-        const running = this.track([uri], call);
+        const running = this.track([uri], () => call(opening));
         running.then(done, done);
         return running;
     }