@g9tm/syncdata 1.5.19 → 1.5.20

package/PARITY.md

@@ -48,6 +48,8 @@ it). This file maps every .NET piece to its twin and lists every deliberate diff
 | A value its type cannot carry refuses only its row, on the device (LES-0088) | `findUnencodable` | `FindUnencodable`: the writer's conversions run before a row enters the batch; a failure is `G9S-REJ-MALFORMED` with the column, counted in `rejectedLocally`; `MalformedLocalValueTests` / `test/malformedLocalValue.test.ts` |
 | Lost = pushed columns only; timestamps as instants (LES-0086) | `pushedMask`, `sameValue(…, type)` / `instant` | `PushedMask` / `SameValue(type, …)` / `Instant`: the dirty mask restricted to the batch's columns; DateTime/DateTimeOffset text in either form equal within one microsecond (TS: no BigInt - milliseconds plus 100 ns units); `HeldValueTests` / `test/heldValues.test.ts` |
 | `SaveHelloAsync(hello, localMidpointUtc, ct)` (LES-0075) | `saveHello(hello, signal, localMidpointMs)` | the engine measures the Hello round trip in both clients and stores `serverTime - midpoint` |
+| `RefetchRowsAsync(table, keys?)` (1.5.19, LES-0090) | `refetchRows(table, keys?)` | the same rows (clean, held: `dirty = 0 AND rejected = 0 AND deleted = 0 AND subs <> 0`) get `server_ver = -1`, their holders NeedsReconcile; the holder bitmask of .NET is one `EXISTS … (subs >> slot) & 1` statement; keys canonicalised, pages of 5000; `test/refetchAndRelease.test.ts` |
+| `ReleaseUnclaimedRowsAsync(table, keys?, includePending)` (1.5.19) | `releaseUnclaimedRows(table, keys?, includePending)` | the same selection (`subs = 0 AND server_ver = 0`, not revoked / quarantined / ephemeral / in a pending command; pending and refused only with `includePending`), read whole before the disposal (`temp.g9_unclaimed`, key order), capture off, reason `G9ERevocationReason.Unclaimed` (4), `changedKeys` capped by `maxChangedKeysPerTable`, RowsApplied (PostStep) when anything left; `test/refetchAndRelease.test.ts`, `test/engine.test.ts`. Until 1.5.20 both were .NET only (1.5.19 shipped without the twins) |
 | `G9CSqliteException` (`IG9SyncLocalStoreFailure`) | `G9SqliteStoreError` (`localStoreFailure`) | classified from the driver's code |
 | `G9CSignalRSyncTransport`, options | `G9SignalRSyncTransport` (`@g9tm/syncdata/signalr`) | over `G9Client` of `@g9tm/signalr-supernetcore-client`; Lynx: `createLynxSyncTransport`. Limits (ADR-0074): `CallTimeout` / `PlanTimeout` / `PushTimeout` / `StreamIdleTimeout` = `callTimeoutMs` / `planTimeoutMs` / `pushTimeoutMs` / `streamIdleTimeoutMs`, same defaults, same retryable `G9S-NET-FAILURE`, same connection drop (`SignalRTimeoutTests` / `test/transportTimeouts.test.ts`). After an automatic reconnect both resend the last accepted Hello so the new connection rejoins its poke groups (LES-0087: `OnReconnectedAsync` / `_rejoin`; `SignalRTransportTests.After_the_connection_reconnects_by_itself_…` / `test/transportRejoin.test.ts`) |
 | `G9CInMemorySyncTransport`, `G9CTransportFaults` | `G9FaultInjectingTransport`, `G9TransportFaults` (`@g9tm/syncdata/testing`) | wraps a real transport (no in-process server engine in JavaScript) |

package/dist/client/engine.d.ts

@@ -2,7 +2,7 @@ import { G9SyncParameters } from '../abstractions/parameters.js';
 import { type G9DtHelloResult, type G9DtNegotiatedTable, type G9DtSubscriptionState } from '../protocol/dtos.js';
 import type { G9SyncClientModel } from './model.js';
 import { G9SyncRun, type G9RowsAppliedEvent, type G9SubscriptionOptions, type G9SyncEngineOptions, type G9SyncHealth, type G9SyncRequest, type G9SyncRunResult } from './runs.js';
-import { type G9ChangeFeedEntry, type G9ChangeFeedKeyFilter, type G9LocalCommand, type G9LocalCommandWriter, type G9ELocalCommandState, type G9PendingSummary, type G9QuarantinedRow, type G9RetainedRow, type G9SyncClientStore, type G9SyncRejection, type G9SyncSubscriptionRecord } from './storeTypes.js';
+import { G9ApplyReport, type G9ChangeFeedEntry, type G9ChangeFeedKeyFilter, type G9LocalCommand, type G9LocalCommandWriter, type G9ELocalCommandState, type G9PendingSummary, type G9QuarantinedRow, type G9RetainedRow, type G9SyncClientStore, type G9SyncRejection, type G9SyncSubscriptionRecord } from './storeTypes.js';
 import type { G9SyncTransport } from './transport.js';
 /**
  * The client sync engine (`G9CSyncEngine`): one per local database. Owns a prioritised run queue, so status queries
@@ -91,6 +91,21 @@ export declare class G9SyncEngine {
     getChangeFeedFloor(signal?: AbortSignal): Promise<number>;
     adoptExistingRows(signal?: AbortSignal): Promise<number>;
     markDirty(localTable: string, keys: readonly string[], signal?: AbortSignal): Promise<number>;
+    /**
+     * `RefetchRowsAsync` (1.5.19): has the next sync fetch these rows again and overwrite their local values with the server's
+     * (all of a table, or `keys`) - for a server whose READ of a column changed while the rows did not, e.g. a column it now
+     * serves empty (a reconcile compares key + version, never values). Only clean rows a subscription holds; a row with a pending
+     * change, a rejection or a delete is left alone. Nothing is uploaded. Their subscriptions become NeedsReconcile, so the next
+     * sync of any kind does it, offline in between or not. Returns the rows marked.
+     */
+    refetchRows(localTable: string, keys?: readonly string[] | null, signal?: AbortSignal): Promise<number>;
+    /**
+     * `ReleaseUnclaimedRowsAsync` (1.5.19): removes rows of one table (all, or `keys`) that no subscription holds and the server
+     * never claimed (`server_ver = 0`: adopted from the device's own table, never confirmed since). Locally only: capture is off,
+     * nothing is uploaded. A row with a pending (or refused) change stays unless `includePending` - then the revocation policy
+     * decides (by default quarantined, the refusal with it). Raises RowsApplied (PostStep) when anything left.
+     */
+    releaseUnclaimedRows(localTable: string, keys?: readonly string[] | null, includePending?: boolean, signal?: AbortSignal): Promise<G9ApplyReport>;
     getHealth(signal?: AbortSignal): Promise<G9SyncHealth>;
     dispose(): Promise<void>;
     private _signal;

package/dist/client/engine.js

@@ -276,6 +276,34 @@ export class G9SyncEngine {
         await this.initialize(signal);
         return this._store.markDirty(localTable, keys, signal);
     }
+    /**
+     * `RefetchRowsAsync` (1.5.19): has the next sync fetch these rows again and overwrite their local values with the server's
+     * (all of a table, or `keys`) - for a server whose READ of a column changed while the rows did not, e.g. a column it now
+     * serves empty (a reconcile compares key + version, never values). Only clean rows a subscription holds; a row with a pending
+     * change, a rejection or a delete is left alone. Nothing is uploaded. Their subscriptions become NeedsReconcile, so the next
+     * sync of any kind does it, offline in between or not. Returns the rows marked.
+     */
+    async refetchRows(localTable, keys = null, signal) {
+        if (!localTable || !localTable.trim())
+            throw new Error('localTable is required');
+        await this.initialize(signal);
+        return this._store.refetchRows(localTable, keys, signal);
+    }
+    /**
+     * `ReleaseUnclaimedRowsAsync` (1.5.19): removes rows of one table (all, or `keys`) that no subscription holds and the server
+     * never claimed (`server_ver = 0`: adopted from the device's own table, never confirmed since). Locally only: capture is off,
+     * nothing is uploaded. A row with a pending (or refused) change stays unless `includePending` - then the revocation policy
+     * decides (by default quarantined, the refusal with it). Raises RowsApplied (PostStep) when anything left.
+     */
+    async releaseUnclaimedRows(localTable, keys = null, includePending = false, signal) {
+        if (!localTable || !localTable.trim())
+            throw new Error('localTable is required');
+        await this.initialize(signal);
+        const report = await this._store.releaseUnclaimedRows(localTable, keys, includePending, signal);
+        if (report.revokedDeleted + report.revokedQuarantined + report.revokedRetained > 0)
+            this._raiseRowsApplied(report, G9ESyncPhase.PostStep);
+        return report;
+    }
     async getHealth(signal) {
         await this.initialize(signal);
         const state = await this._store.getServerState(signal);