@effect-agent/storage-sqlite 0.1.0-beta.69 → 0.1.0-beta.71

package/dist/SqliteMessageDeliveryStore.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as initializeSqliteJournal } from "./sqlite-journal-CC4oPmgO.mjs";
+import { a as initializeSqliteJournal } from "./sqlite-journal-D9xFxCw-.mjs";
 import { MessageDeliveryError, MessageDeliveryStore } from "@effect-agent/thread/MessageDelivery";
 import { SqlMessageDeliveryTransaction, makeSqlMessageDeliveryStore } from "@effect-agent/thread/SqlMessageDeliveryStore";
 import { Effect, Layer } from "effect";

package/dist/SqliteScheduleStore.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as initializeSqliteJournal } from "./sqlite-journal-CC4oPmgO.mjs";
+import { a as initializeSqliteJournal } from "./sqlite-journal-D9xFxCw-.mjs";
 import { Effect, Layer, Result, Schema } from "effect";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
 import { ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleId, ScheduleInstant, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, defaultSchedulingLimits } from "@effect-agent/thread/Schedule";

package/dist/{SqliteStorageVersion-GivCOblh.d.mts → SqliteStorageVersion-BqmqX0CI.d.mts}

@@ -1,9 +1,11 @@
+import { Effect } from "effect";
+import "effect/unstable/sql/SqlClient";
 import { SqliteMigrator } from "@effect/sql-sqlite-node";
 //#region src/internal/migrations.d.ts
-declare const CurrentSqliteStorageVersion = 10;
+declare const CurrentSqliteStorageVersion = 11;
 declare namespace SqliteStorageVersion_d_exports {
   export { CurrentSqliteStorageVersion };
 }
 //#endregion
 export { CurrentSqliteStorageVersion as n, SqliteStorageVersion_d_exports as t };
-//# sourceMappingURL=SqliteStorageVersion-GivCOblh.d.mts.map
+//# sourceMappingURL=SqliteStorageVersion-BqmqX0CI.d.mts.map

package/dist/SqliteStorageVersion.d.mts

@@ -1,2 +1,2 @@
-import { n as CurrentSqliteStorageVersion } from "./SqliteStorageVersion-GivCOblh.mjs";
+import { n as CurrentSqliteStorageVersion } from "./SqliteStorageVersion-BqmqX0CI.mjs";
 export { CurrentSqliteStorageVersion };

package/dist/SqliteStorageVersion.mjs

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { t as CurrentSqliteStorageVersion } from "./migrations-NWxfq43W.mjs";
+import { t as CurrentSqliteStorageVersion } from "./migrations-Dy5v0HGe.mjs";
 //#region src/SqliteStorageVersion.ts
-var SqliteStorageVersion_exports = /* @__PURE__ */ __exportAll({ CurrentSqliteStorageVersion: () => 10 });
+var SqliteStorageVersion_exports = /* @__PURE__ */ __exportAll({ CurrentSqliteStorageVersion: () => 11 });
 //#endregion
 export { CurrentSqliteStorageVersion, SqliteStorageVersion_exports as t };
 

package/dist/SqliteSubmissionLedger.mjs

@@ -2,7 +2,7 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { SqliteStorageConfig } from "./SqliteStorageConfig.mjs";
 import { SqliteLedgerError, SqliteStorageCorruptionError, SqliteStorageError, SqliteWriteContention } from "./SqliteStorageError.mjs";
 import { SqliteStorageFailpoint } from "./SqliteStorageFailpoint.mjs";
-import { a as initializeSqliteJournal, i as decodeRows } from "./sqlite-journal-CC4oPmgO.mjs";
+import { a as initializeSqliteJournal, i as decodeRows } from "./sqlite-journal-D9xFxCw-.mjs";
 import { storageConfigLayer, storageFailpointLayer } from "./SqliteThreadStore.mjs";
 import { Clock, Context, Crypto, DateTime, Effect, Layer, Option, Schema, Stream } from "effect";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
@@ -928,39 +928,68 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 		yield* hitFailpoint("ledger:reserve-settlement:after", operation);
 		return reserved;
 	});
+	const validateFinalization = Effect.fn("SqliteSubmissionLedger.validateFinalization")(function* (validated, reservation) {
+		const operation = "ledger finalize settlement";
+		if (Option.isNone(reservation)) return yield* LedgerError.make({
+			operation,
+			message: `No settlement reservation exists for submission ${validated.submissionId}.`
+		});
+		if (reservation.value.settlement_id !== validated.settlementId) return yield* SettlementConflict.make({
+			submissionId: validated.submissionId,
+			existingOutcome: reservation.value.outcome
+		});
+		const reservationRecord = yield* decodeRecordEnvelopeText(reservation.value.record_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, error.message)));
+		const settlementFailure = settlementFailureFromRecord(reservationRecord);
+		if (reservation.value.outcome === "failed" !== (settlementFailure !== void 0)) return yield* corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, "The reserved outcome and canonical failure diagnostic disagree.");
+		return {
+			reservation: reservation.value,
+			settlementFailure
+		};
+	});
+	const replayFinalization = Effect.fn("SqliteSubmissionLedger.replayFinalization")(function* (validated, submission, { reservation, settlementFailure }) {
+		const operation = "ledger finalize settlement";
+		if (reservation.finalized_at === null) return yield* corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, "A settled Submission's reservation carries no finalization timestamp.");
+		return yield* decodeSettlement({
+			submissionId: validated.submissionId,
+			settlementId: validated.settlementId,
+			receiptId: submission.receipt_id,
+			outcome: reservation.outcome,
+			...settlementFailure === void 0 ? {} : { failure: settlementFailure },
+			settledAt: reservation.finalized_at
+		}).pipe(Effect.mapError(internalFailure(operation)));
+	});
 	const finalizeSettlement = Effect.fn("SqliteSubmissionLedger.finalizeSettlement")(function* (request) {
 		const operation = "ledger finalize settlement";
 		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SettlementFinalization))(request).pipe(Effect.mapError(internalFailure(operation)));
 		yield* hitFailpoint("ledger:finalize-settlement:before", operation);
+		const replayRows = yield* sql`
+      SELECT submission.*, reservation.settlement_id, reservation.outcome,
+        reservation.record_id, reservation.record_json, reservation.record_digest,
+        reservation.reserved_at, reservation.finalized_at
+      FROM effect_agent_submissions AS submission
+      INNER JOIN effect_agent_settlement_reservations AS reservation
+        ON reservation.submission_id = submission.submission_id
+      WHERE submission.submission_id = ${validated.submissionId} AND submission.state = 'settled'
+    `.pipe(Effect.mapError(sqlFailure(operation)));
+		if (replayRows.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A submission primary key returned more than one row.");
+		const replayRow = replayRows[0];
+		if (replayRow !== void 0) {
+			const reservations = yield* decodeRows(Schema.Array(ReservationRow), "effect_agent_settlement_reservations", validated.submissionId, replayRows).pipe(Effect.mapError(internalFailure(operation)));
+			const state = yield* validateFinalization(validated, Option.fromUndefinedOr(reservations[0]));
+			const submission = yield* Schema.decodeUnknownEffect(SubmissionRow)(replayRow).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, error.message)));
+			const settlement = yield* replayFinalization(validated, submission, state);
+			yield* hitFailpoint("ledger:finalize-settlement:after", operation);
+			return settlement;
+		}
 		const settlement = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const reservation = yield* readReservation(operation, validated.submissionId);
-			if (Option.isNone(reservation)) return yield* LedgerError.make({
-				operation,
-				message: `No settlement reservation exists for submission ${validated.submissionId}.`
-			});
-			if (reservation.value.settlement_id !== validated.settlementId) return yield* SettlementConflict.make({
-				submissionId: validated.submissionId,
-				existingOutcome: reservation.value.outcome
-			});
-			const reservationRecord = yield* decodeRecordEnvelopeText(reservation.value.record_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, error.message)));
-			const settlementFailure = settlementFailureFromRecord(reservationRecord);
-			if (reservation.value.outcome === "failed" !== (settlementFailure !== void 0)) return yield* corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, "The reserved outcome and canonical failure diagnostic disagree.");
+			const state = yield* validateFinalization(validated, yield* readReservation(operation, validated.submissionId));
+			const { reservation, settlementFailure } = state;
 			const submission = yield* requireSubmission(operation, validated.submissionId);
-			if (submission.state === "settled") {
-				if (reservation.value.finalized_at === null) return yield* corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, "A settled Submission's reservation carries no finalization timestamp.");
-				return yield* decodeSettlement({
-					submissionId: validated.submissionId,
-					settlementId: validated.settlementId,
-					receiptId: submission.receipt_id,
-					outcome: reservation.value.outcome,
-					...settlementFailure === void 0 ? {} : { failure: settlementFailure },
-					settledAt: reservation.value.finalized_at
-				}).pipe(Effect.mapError(internalFailure(operation)));
-			}
+			if (submission.state === "settled") return yield* replayFinalization(validated, submission, state);
 			const now = yield* currentInstant;
 			yield* sql`
           UPDATE effect_agent_submissions
-          SET state = 'settled', settled_outcome = ${reservation.value.outcome}
+          SET state = 'settled', settled_outcome = ${reservation.outcome}
           WHERE submission_id = ${validated.submissionId}
         `.pipe(Effect.mapError(sqlFailure(operation)));
 			yield* sql`
@@ -976,7 +1005,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 				submissionId: validated.submissionId,
 				settlementId: validated.settlementId,
 				receiptId: submission.receipt_id,
-				outcome: reservation.value.outcome,
+				outcome: reservation.outcome,
 				...settlementFailure === void 0 ? {} : { failure: settlementFailure },
 				settledAt: now.iso
 			}).pipe(Effect.mapError(internalFailure(operation)));
@@ -1560,13 +1589,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           SELECT ${sql.literal(SUBMISSION_COLUMNS)}
           FROM effect_agent_submissions
           WHERE state <> 'settled'
-            AND (
-              thread_id > ${cursor.threadId}
-              OR (
-                thread_id = ${cursor.threadId}
-                AND queue_sequence > ${cursor.queueSequence}
-              )
-            )
+            AND (thread_id, queue_sequence) > (${cursor.threadId}, ${cursor.queueSequence})
           ORDER BY thread_id ASC, queue_sequence ASC
           LIMIT ${SCAN_PAGE_SIZE}
         `).pipe(Effect.mapError(sqlFailure(operation)));