zidane 5.14.0 → 5.14.2

package/dist/restate.js

@@ -652,13 +652,40 @@ const KEY_RUNS = "session-runs";
 function restateSessionStore(ctx) {
 	let nextTurnSeq;
 	let warnedMismatch = false;
+	let headerCache;
+	let turnsCache;
+	let runsCache;
+	async function loadHeader() {
+		if (headerCache === void 0) headerCache = await ctx.get(KEY_DATA);
+		return headerCache;
+	}
+	async function loadTurns() {
+		if (turnsCache === void 0) turnsCache = sanitizeTurnsForState(await ctx.get(KEY_TURNS) ?? []);
+		return turnsCache;
+	}
+	async function loadRuns() {
+		if (runsCache === void 0) runsCache = sanitizeRunsForState(await ctx.get(KEY_RUNS) ?? []);
+		return runsCache;
+	}
+	function writeHeader(header) {
+		headerCache = header;
+		ctx.set(KEY_DATA, header);
+	}
+	function writeTurns(turns) {
+		turnsCache = turns;
+		ctx.set(KEY_TURNS, turns);
+	}
+	function writeRuns(runs) {
+		runsCache = runs;
+		ctx.set(KEY_RUNS, runs);
+	}
 	function guardSessionId(sessionId) {
 		if (warnedMismatch || sessionId === ctx.key) return;
 		warnedMismatch = true;
 		process.stderr.write(`[zidane/restate] restateSessionStore: sessionId "${sessionId}" != bound object key "${ctx.key}". This store ignores the sessionId and operates on the bound object — pass createSession({ id: ctx.key }) to silence this.\n`);
 	}
 	async function generateTurnId() {
-		if (nextTurnSeq === void 0) nextTurnSeq = (await ctx.get(KEY_TURNS) ?? []).length;
+		if (nextTurnSeq === void 0) nextTurnSeq = (await loadTurns()).length;
 		nextTurnSeq += 1;
 		return `turn_${nextTurnSeq}`;
 	}
@@ -672,15 +699,15 @@ function restateSessionStore(ctx) {
 		generateTurnId,
 		async load(_sessionId) {
 			guardSessionId(_sessionId);
-			const header = await ctx.get(KEY_DATA);
-			const turns = sanitizeTurnsForState(await ctx.get(KEY_TURNS) ?? []);
-			const runs = sanitizeRunsForState(await ctx.get(KEY_RUNS) ?? []);
+			const header = await loadHeader();
+			const turns = await loadTurns();
+			const runs = await loadRuns();
 			if (!header) {
 				if (turns.length === 0 && runs.length === 0) return null;
 				return {
 					id: _sessionId,
-					turns,
-					runs,
+					turns: [...turns],
+					runs: [...runs],
 					status: inferStatus(runs),
 					metadata: {},
 					createdAt: inferCreatedAt(turns, runs),
@@ -689,28 +716,32 @@ function restateSessionStore(ctx) {
 			}
 			return {
 				...header,
-				turns,
-				runs
+				turns: [...turns],
+				runs: [...runs]
 			};
 		},
 		async save(session) {
 			guardSessionId(session.id);
 			const { turns, runs, ...header } = session;
-			const prior = await ctx.get(KEY_DATA);
+			const prior = await loadHeader();
 			const now = await ctx.date.now();
-			ctx.set(KEY_DATA, {
+			writeHeader({
 				...header,
 				createdAt: prior?.createdAt ?? now,
 				updatedAt: now
 			});
-			ctx.set(KEY_TURNS, sanitizeTurnsForState(turns));
-			ctx.set(KEY_RUNS, sanitizeRunsForState(runs));
+			writeTurns(sanitizeTurnsForState(turns));
+			writeRuns(sanitizeRunsForState(runs));
 		},
 		async delete(_sessionId) {
 			guardSessionId(_sessionId);
 			ctx.clear(KEY_DATA);
 			ctx.clear(KEY_TURNS);
 			ctx.clear(KEY_RUNS);
+			headerCache = null;
+			turnsCache = [];
+			runsCache = [];
+			nextTurnSeq = void 0;
 		},
 		/**
 		* Always empty — virtual objects don't support cross-key
@@ -722,16 +753,15 @@ function restateSessionStore(ctx) {
 		},
 		async appendTurns(_sessionId, turns) {
 			guardSessionId(_sessionId);
-			const existing = sanitizeTurnsForState(await ctx.get(KEY_TURNS) ?? []);
-			ctx.set(KEY_TURNS, [...existing, ...sanitizeTurnsForState(turns)]);
+			writeTurns([...await loadTurns(), ...sanitizeTurnsForState(turns)]);
 		},
 		async getTurns(_sessionId, from = 0, limit) {
 			guardSessionId(_sessionId);
-			return sanitizeTurnsForState(await ctx.get(KEY_TURNS) ?? []).slice(from, limit !== void 0 ? from + limit : void 0);
+			return (await loadTurns()).slice(from, limit !== void 0 ? from + limit : void 0);
 		},
 		async updateRun(_sessionId, run) {
 			guardSessionId(_sessionId);
-			const runs = sanitizeRunsForState(await ctx.get(KEY_RUNS) ?? []);
+			const runs = await loadRuns();
 			const idx = runs.findIndex((r) => r.id === run.id);
 			const next = [...runs];
 			if (idx >= 0) next[idx] = {
@@ -739,18 +769,18 @@ function restateSessionStore(ctx) {
 				startedAt: runs[idx].startedAt
 			};
 			else next.push(sanitizeRunForState(run));
-			ctx.set(KEY_RUNS, next);
+			writeRuns(next);
 		},
 		async updateStatus(_sessionId, status) {
 			guardSessionId(_sessionId);
-			const header = await ctx.get(KEY_DATA);
+			const header = await loadHeader();
 			const now = await ctx.date.now();
-			if (header) ctx.set(KEY_DATA, {
+			if (header) writeHeader({
 				...header,
 				status,
 				updatedAt: now
 			});
-			else ctx.set(KEY_DATA, {
+			else writeHeader({
 				id: _sessionId,
 				status,
 				metadata: {},