@g9tm/syncdata 1.5.20 → 1.5.21

package/PARITY.md

@@ -79,6 +79,13 @@ it). This file maps every .NET piece to its twin and lists every deliberate diff
   would hand out, in model order) so its triggers are written in the same batch. Same objects, rows, tids and counter
   (`test/provision.test.ts` compares both paths on fresh, reopened, evolved and repaired databases). AgriPad's 47 tables:
   14 driver calls on every start instead of 296, 17 instead of 534 on the first.
+- **Hello sends the model once per connection (1.5.21).** `G9CSignalRSyncTransport.HelloAsync` / `G9SignalRSyncTransport.hello`
+  strip the tables on a later Hello of the same connection (`_modelOnConnection`, keyed by the connection id and the engine's one
+  model list/array) and resend them inside the call on `ModelRequired`; the engines keep the last answer in memory
+  (`G9CSyncEngine.HelloCache` / `_lastAnswer`), send `KnownTablesHash` / `KnownDefinitionsHash` and put back what an "unchanged"
+  answer left out (`RestoreUnchanged` / `restoreUnchanged`); both stores skip `definitions_json`, `tables_json` and the per-table
+  updates of an unchanged answer. Tests: `HelloModelOnceTests` / `test/transportModelOnce.test.ts`; the golden Hello samples carry
+  the six new fields.
 - **Per-run bookkeeping.** `saveHello` writes the meta rows, the definitions' move-out policies and every negotiated
   table (with its capture triggers) in ONE batch, after one read for the only per-table question (does a table with
   newly negotiated columns hold rows?); the rows an apply protects (`readRowsChangedAfter`) are read with one

package/dist/client/engine.d.ts

@@ -32,6 +32,13 @@ export declare class G9SyncEngine {
     private _disposed;
     /** The model problems last logged, so the warning is said once per distinct set (ADR-0061). */
     private _reportedModelProblems;
+    /**
+     * What Hello does not send again (1.5.21, TR-0069; twin of .NET `G9CSyncEngine.HelloCache`): the last negotiated tables and definitions,
+     * with the server's ids for them. In memory only: the first Hello of a process gets them in full.
+     */
+    private _lastAnswer;
+    /** The model as Hello sends it, built once: the transport recognises an unchanged model by this very array. */
+    private _wireTables;
     constructor(store: G9SyncClientStore, transport: G9SyncTransport, model: G9SyncClientModel, options?: G9SyncEngineOptions);
     get clientId(): string;
     get isRunning(): boolean;

package/dist/client/engine.js

@@ -42,6 +42,13 @@ export class G9SyncEngine {
         this._disposed = false;
         /** The model problems last logged, so the warning is said once per distinct set (ADR-0061). */
         this._reportedModelProblems = null;
+        /**
+         * What Hello does not send again (1.5.21, TR-0069; twin of .NET `G9CSyncEngine.HelloCache`): the last negotiated tables and definitions,
+         * with the server's ids for them. In memory only: the first Hello of a process gets them in full.
+         */
+        this._lastAnswer = null;
+        /** The model as Hello sends it, built once: the transport recognises an unchanged model by this very array. */
+        this._wireTables = null;
         if (!store)
             throw new TypeError('A store is required.');
         if (!transport)
@@ -459,6 +466,7 @@ export class G9SyncEngine {
     }
     // ================================================================ execution
     async _executeRun(run) {
+        var _a, _b, _c;
         const request = run.request;
         const startedUtcMs = Date.now();
         const changes = new G9ApplyReport();
@@ -493,10 +501,19 @@ export class G9SyncEngine {
                     hostScope = await this._options.hooks.beginRun(run, ct);
                 // ---------------------------------------------------------------- 1. connect + hello
                 tracker.enter(G9ESyncPhase.Connecting);
+                // Where the Connecting phase goes (AgriPad TR-0069, 2026-11-13: «Connecting takes long»): each step is timed and the
+                // split logged once per run (event 20030) — the transport, the ephemeral sweep, reading the subscriptions, the
+                // Hello round trip and the save of its answer are separate costs with separate cures.
+                const connectT0 = Date.now();
                 await this._ensureConnected(ct);
+                const connectT1 = Date.now();
                 await this._store.collectExpiredEphemeral(Date.now(), ct);
+                const connectT2 = Date.now();
                 const subscriptions = await this._store.getSubscriptions(ct);
+                const connectT3 = Date.now();
                 let helloMidpointMs = Date.now();
+                const known = this._lastAnswer;
+                const wireTables = (_a = this._wireTables) !== null && _a !== void 0 ? _a : (this._wireTables = this.model.tables.map((t) => t.toWire()));
                 const hello = await this._withRetry(async (token) => {
                     // The round trip of the attempt that answered: its midpoint is the local time of the server's clock reading (LES-0075).
                     const sent = Date.now();
@@ -504,15 +521,34 @@ export class G9SyncEngine {
                         clientId: this._clientId,
                         appVersion: this._options.appVersion,
                         protocolVersion: 1,
-                        tables: this.model.tables.map((t) => t.toWire()),
+                        tables: wireTables,
                         subscriptions: subscriptions.map(toSubscriptionRef),
+                        knownTablesHash: known ? known.tablesHash : null,
+                        knownDefinitionsHash: known ? known.definitionsHash : null,
                     }, token);
                     helloMidpointMs = sent + (Date.now() - sent) / 2;
                     return answer;
                 }, ct);
                 if (hello.error)
                     throw syncErrorToException(hello.error);
+                const unchanged = (hello.tablesUnchanged ? 'tables' : '') + (hello.definitionsUnchanged ? (hello.tablesUnchanged ? '+' : '') + 'definitions' : '');
+                restoreUnchanged(hello, known);
+                const connectT4 = Date.now();
                 await this._store.saveHello(hello, ct, helloMidpointMs);
+                this._lastAnswer =
+                    hello.tablesHash || hello.definitionsHash
+                        ? {
+                            tablesHash: (_b = hello.tablesHash) !== null && _b !== void 0 ? _b : null,
+                            tables: hello.tables,
+                            unknownTables: hello.unknownTables,
+                            definitionsHash: (_c = hello.definitionsHash) !== null && _c !== void 0 ? _c : null,
+                            definitions: hello.definitions,
+                        }
+                        : null;
+                const connectT5 = Date.now();
+                this._log('information', 20030, `Connecting ${connectT5 - connectT0} ms: transport ${connectT1 - connectT0}, ephemeral sweep ${connectT2 - connectT1}, ` +
+                    `subscriptions ${connectT3 - connectT2} (${subscriptions.length}), hello ${connectT4 - connectT3} ` +
+                    `(${this.model.tables.length} tables; unchanged: ${unchanged || 'none'}), save ${connectT5 - connectT4}`);
                 if (hello.unknownTables.length > 0) {
                     this._log('warning', 20016, 'The server does not know these client tables (they will not sync): ' + hello.unknownTables.join(', '));
                 }
@@ -1258,4 +1294,21 @@ async function* toChunks(batch) {
     for (const frame of batch.frames)
         yield { sequence: sequence++, payload: frame, rowCount: 0, isFinal: false };
 }
+/**
+ * Puts back what an "unchanged" Hello answer left out (1.5.21; twin of .NET `RestoreUnchanged`), so the rest of a run reads a complete
+ * answer either way. An answer that says unchanged for something this client never held is a server fault.
+ */
+function restoreUnchanged(hello, known) {
+    if (hello.tablesUnchanged) {
+        if (!known)
+            throw new G9SyncException(G9SyncErrorCodes.ProtocolMismatch, "The server answered 'tables unchanged' to a client that holds none.");
+        hello.tables = known.tables;
+        hello.unknownTables = known.unknownTables;
+    }
+    if (hello.definitionsUnchanged) {
+        if (!known)
+            throw new G9SyncException(G9SyncErrorCodes.ProtocolMismatch, "The server answered 'definitions unchanged' to a client that holds none.");
+        hello.definitions = known.definitions;
+    }
+}
 //# sourceMappingURL=engine.js.map