@hydranium/protocol 1.0.0-next.227 → 1.0.0-next.229

package/src/client/data-session.ts

@@ -222,8 +222,9 @@ export type DataSessionFactory<TTransfer extends TransferElement, TServer extend
  * re-opens and re-watches what it had open, tells the client of their dirty
  * state where it changed, and reports the documents whose unsaved edits did
  * not survive; see {@link restore}. The connection does this at
- * once for a session with documents open, and any session's next call does it
- * too.
+ * once for a session with documents open, and again once any later connection
+ * is ready, so a reconnect that failed is not left to the session's own next
+ * call; any session's next call does it too.
  *
  * Generic over the transfer root so this file names no grammar.
  *
@@ -350,6 +351,9 @@ export class DataSession<
          this.registration = this.register(server, reconnected);
       }
       await this.registration;
+      // And after the registration: a call waiting on it has not reached the
+      // wire, and sent now it would land after the session's close.
+      this.assertLive();
       return server;
    }
 
@@ -635,8 +639,9 @@ export class DataSession<
    /**
     * Register again and restore now, after the connection dropped, instead of
     * on the next call. A no-op for a session with nothing open, which the next
-    * call restores anyway. A failure is left to that next call, which meets it
-    * again.
+    * call restores anyway, and for one already registered on the current
+    * connection. A failure is retried on the connection's next ready
+    * generation; a call before then meets it again.
     */
    reconnect(): void {
       if (!this.disposed && this.openUris.size > 0) {

package/src/client/rpc-connection.ts

@@ -229,6 +229,8 @@ export class RpcConnection<TServer extends ReadyServer, TClient extends object>
             return;
          }
          await generation.server.waitForReady();
+         // Before `onReady`, so a failing restore reports a failure alone.
+         this.generationReady(generation);
          this.lifecycle.onReady?.();
       } catch (error: unknown) {
          // A dropped generation's request fails with its transport, which says
@@ -247,6 +249,17 @@ export class RpcConnection<TServer extends ReadyServer, TClient extends object>
       }
    }
 
+   /**
+    * Called once `generation` has passed its readiness gate, whichever request
+    * brought it up. A generation can replace one that failed at readiness
+    * without {@link dropGeneration}, so this, not a drop, is where state kept
+    * on the server is put back. It runs inside the readiness gate, so a throw
+    * from an override fails the generation as a refused gate would.
+    */
+   protected generationReady(_generation: RpcConnectionGeneration<TServer>): void {
+      // Nothing to put back at this layer.
+   }
+
    /**
     * Discard the current generation, disposing its connection if it opened.
     * The next {@link connected} builds a fresh one.

package/src/messages/index.ts

@@ -26,6 +26,7 @@
 export * from './primitives';
 
 export { DOCUMENT_NOT_OPEN, DUPLICATE_CLIENT_ID, SESSION_CLOSED, STALE_BASE_VERSION_UPDATE } from '../errors';
+export { DATA_CONNECTION_SESSION_RESTORE_FAILED, DATA_CONNECTION_WATCH_RESTORE_FAILED } from '../client/data-connection';
 export { DATA_SERVER_CONNECT_FAILED, DATA_SERVER_NOT_READY } from '../client/rpc-connection';
 export { DATA_SESSION_ANSWER_WITHOUT_MODEL, DATA_SESSION_RESTORE_FAILED, DATA_SESSION_UNSAVED_LOST } from '../client/data-session';
 export {

package/src/testing/data-doubles.ts

@@ -43,6 +43,7 @@ import type {
    TransferDocumentsBuiltEvent,
    TransferDocumentUpdatedEvent
 } from '../data/events';
+import type { Logger } from '../logger';
 import type { ResolvedMessage } from '../messages/primitives';
 import type { RpcProxyLifecycle } from '../rpc/create-rpc-proxy';
 import type { Project } from '../project';
@@ -61,6 +62,8 @@ export interface FakeDataPortOptions {
     * which the consumer surfaces through {@link FakeDataPort.reported}.
     */
    connect(): MessageConnection | Promise<MessageConnection>;
+   /** The port's {@link DataPort.logger}. */
+   logger?: Logger;
 }
 
 /** A {@link DataPort} that records what passed through it. */
@@ -105,6 +108,7 @@ export function makeFakeDataPort(options: FakeDataPortOptions): FakeDataPort {
    return {
       connections,
       reported,
+      logger: options.logger,
       onDispose: disposeEmitter.event,
       async connect(): Promise<MessageConnection> {
          const connection = await options.connect();