@forgeax/engine-ddc 0.1.6 → 0.1.19

package/src/session.ts

@@ -1,6 +1,13 @@
 import type { DdcEntry, StagedDdcEntry } from './entry-store.js';
 import { DdcEntryStore } from './entry-store.js';
-import type { DdcCommitResult, DdcHead, DdcLease } from './lifecycle.js';
+import type {
+  DdcCommitResult,
+  DdcHead,
+  DdcLease,
+  DdcRestoreFence,
+  DdcRestoreResult,
+  DdcRollbackSnapshot,
+} from './lifecycle.js';
 import { DdcLifecycle } from './lifecycle.js';
 
 export interface DdcSessionOptions {
@@ -11,7 +18,7 @@ export interface DdcSessionOptions {
 export interface DdcGenerationCandidate {
   readonly generation: number;
   readonly lease: DdcLease;
-  readonly previousHead: DdcHead;
+  readonly previousHead: DdcRollbackSnapshot;
 }
 
 export interface DdcGenerationEntryCandidate extends DdcGenerationCandidate {
@@ -47,6 +54,7 @@ export class DdcGenerationSession {
   private readonly lifecycle: DdcLifecycle;
   private readonly entries: DdcEntryStore;
   private readonly candidates = new Map<string, MutableDdcGenerationCandidate>();
+  private readonly restoreFences = new WeakMap<DdcGenerationCandidate, DdcRestoreFence>();
   private readonly heartbeatTimers = new Map<string, HeartbeatTimer>();
   private readonly counters: MutableMetrics = {
     hitCount: 0,
@@ -69,12 +77,14 @@ export class DdcGenerationSession {
   }
 
   public async beginCandidate(guid: string, desiredKey: string): Promise<DdcGenerationCandidate> {
-    const head = await this.inspect(guid, desiredKey);
-    const lease = await this.lifecycle.begin(guid, desiredKey);
+    this.assertOpen();
+    const { lease, previousHead } = await this.lifecycle.beginWithSnapshot(guid, desiredKey);
+    if (previousHead.state === 'current') this.counters.hitCount += 1;
+    else this.counters.missCount += 1;
     const candidate: MutableDdcGenerationCandidate = {
       generation: this.generation,
       lease,
-      previousHead: head,
+      previousHead,
     };
     this.candidates.set(lease.attempt, candidate);
     this.scheduleHeartbeat(candidate);
@@ -95,10 +105,11 @@ export class DdcGenerationSession {
       this.candidates.set(candidate.lease.attempt, entryCandidate);
       return entryCandidate;
     } catch (error) {
-      await this.lifecycle.fail(candidate.lease, {
+      const fence = await this.lifecycle.fail(candidate.lease, {
         code: 'ddc-entry-stage-failed',
         detail: error instanceof Error ? error.message : String(error),
       });
+      if (fence !== undefined) this.restoreFences.set(candidate, fence);
       this.stopHeartbeat(candidate);
       this.candidates.delete(candidate.lease.attempt);
       this.counters.writeFailureCount += 1;
@@ -121,6 +132,8 @@ export class DdcGenerationSession {
     const registered = this.assertCandidate(candidate);
     try {
       const result = await this.lifecycle.commit(registered.lease, validatedKey);
+      if (result.restoreFence !== undefined)
+        this.restoreFences.set(registered, result.restoreFence);
       if (result.result === 'invalid') this.counters.corruptCount += 1;
       this.stopHeartbeat(registered);
       this.candidates.delete(registered.lease.attempt);
@@ -140,15 +153,18 @@ export class DdcGenerationSession {
     try {
       await this.entries.publish(candidate.staged);
       const result = await this.lifecycle.commit(registered.lease, validatedKey);
+      if (result.restoreFence !== undefined)
+        this.restoreFences.set(registered, result.restoreFence);
       this.stopHeartbeat(registered);
       this.candidates.delete(registered.lease.attempt);
       return result;
     } catch (error) {
       this.stopHeartbeat(registered);
-      await this.lifecycle.fail(registered.lease, {
+      const fence = await this.lifecycle.fail(registered.lease, {
         code: 'ddc-entry-publish-failed',
         detail: error instanceof Error ? error.message : String(error),
       });
+      if (fence !== undefined) this.restoreFences.set(registered, fence);
       await this.entries.discard(candidate.staged).catch(() => {});
       this.candidates.delete(registered.lease.attempt);
       this.counters.writeFailureCount += 1;
@@ -173,21 +189,31 @@ export class DdcGenerationSession {
     await Promise.all([this.discardCandidate(candidate), this.entries.discard(candidate.staged)]);
   }
 
-  public async restoreEntry(candidate: DdcGenerationEntryCandidate): Promise<void> {
+  public async restoreEntry(candidate: DdcGenerationEntryCandidate): Promise<DdcRestoreResult> {
     const registered = this.candidates.get(candidate.lease.attempt);
+    const ownerLease = registered?.lease ?? candidate.lease;
+    const fence = this.restoreFences.get(candidate);
+    this.stopHeartbeat(ownerLease);
+    let result: DdcRestoreResult = {
+      result: 'not-owner',
+      revision: candidate.previousHead.revision ?? 0,
+      ...(candidate.previousHead.generation === undefined
+        ? {}
+        : { generation: candidate.previousHead.generation }),
+    };
     let restoreError: unknown;
     try {
-      await this.lifecycle.restore(candidate.previousHead);
+      result = await this.lifecycle.restoreIfCurrent(candidate.previousHead, ownerLease, fence);
     } catch (error) {
       restoreError = error;
     } finally {
       await this.entries.discard(candidate.staged).catch(() => {});
       if (registered !== undefined) {
-        this.stopHeartbeat(registered);
         this.candidates.delete(registered.lease.attempt);
       }
     }
     if (restoreError !== undefined) throw restoreError;
+    return result;
   }
 
   public metrics(): DdcSessionMetrics {
@@ -245,10 +271,11 @@ export class DdcGenerationSession {
     this.heartbeatTimers.set(attempt, timer);
   }
 
-  private stopHeartbeat(candidate: DdcGenerationCandidate): void {
-    const timer = this.heartbeatTimers.get(candidate.lease.attempt);
+  private stopHeartbeat(candidate: DdcGenerationCandidate | DdcLease): void {
+    const attempt = 'lease' in candidate ? candidate.lease.attempt : candidate.attempt;
+    const timer = this.heartbeatTimers.get(attempt);
     if (timer === undefined) return;
     clearTimeout(timer);
-    this.heartbeatTimers.delete(candidate.lease.attempt);
+    this.heartbeatTimers.delete(attempt);
   }
 }