@mastra/cloudflare 1.7.2 → 1.7.3

package/dist/{do-zOdIsGy9.cjs → do-Uemcag89.cjs}

@@ -103,11 +103,15 @@ var SqlBuilder = class {
 	* @param values Values to insert
 	* @param conflictColumns Columns to check for conflict (usually PK or UNIQUE)
 	* @param updateMap Object mapping columns to update to their new value (e.g. { name: 'excluded.name' })
+	* @param guard Condition the statement writes under: when it is false, neither the insert nor the conflict update happens
 	*/
-	insert(table, columns, values, conflictColumns, updateMap) {
+	insert(table, columns, values, conflictColumns, updateMap, guard) {
 		const parsedTableName = (0, _mastra_core_utils.parseSqlIdentifier)(table, "table name");
 		const parsedColumns = columns.map((col) => (0, _mastra_core_utils.parseSqlIdentifier)(col, "column name"));
 		const placeholders = parsedColumns.map(() => "?").join(", ");
+		const source = guard ? `SELECT ${placeholders} WHERE ${guard.sql}` : `VALUES (${placeholders})`;
+		this.sql = `INSERT INTO ${parsedTableName} (${parsedColumns.join(", ")}) ${source}`;
+		this.params.push(...values, ...guard?.params ?? []);
 		if (conflictColumns && updateMap) {
 			const parsedConflictColumns = conflictColumns.map((col) => (0, _mastra_core_utils.parseSqlIdentifier)(col, "column name"));
 			const excludedPattern = /^excluded\.[a-zA-Z_][a-zA-Z0-9_]*$/;
@@ -117,12 +121,8 @@ var SqlBuilder = class {
 				if (!excludedPattern.test(expr) && !coalescePattern.test(expr)) throw new Error(`Invalid update expression for column ${col}: must be 'excluded.<column>' or 'COALESCE(excluded.<column>, <table>.<column>)' pattern`);
 				return `${parsedCol} = ${expr}`;
 			}).join(", ");
-			this.sql = `INSERT INTO ${parsedTableName} (${parsedColumns.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${parsedConflictColumns.join(", ")}) DO UPDATE SET ${updateClause}`;
-			this.params.push(...values);
-			return this;
+			this.sql += ` ON CONFLICT(${parsedConflictColumns.join(", ")}) DO UPDATE SET ${updateClause}`;
 		}
-		this.sql = `INSERT INTO ${parsedTableName} (${parsedColumns.join(", ")}) VALUES (${placeholders})`;
-		this.params.push(...values);
 		return this;
 	}
 	update(table, columns, values) {
@@ -268,6 +268,67 @@ function parseSelectIdentifier(column) {
 	return column;
 }
 //#endregion
+//#region src/do/storage/db/run-fencing.ts
+/**
+* Epoch milliseconds on the database clock. `julianday('now')` rather than
+* `unixepoch('subsec')`, which needs SQLite 3.42.
+*/
+const DB_NOW_MS = `CAST(ROUND((julianday('now') - 2440587.5) * 86400000) AS INTEGER)`;
+/**
+* The condition a fenced statement writes under: the check's fence is the
+* run's current claim. A Durable Object serves other requests whenever it
+* awaits I/O, so a fenced write can't check the claim first and write later; each of its statements carries this condition instead, and
+* SQLite evaluates it atomically with the write.
+*/
+function runFenceGuard(check) {
+	if (!check) return void 0;
+	const { claimsTable, fence } = check;
+	return {
+		sql: `EXISTS (SELECT 1 FROM ${claimsTable} AS run_fence WHERE run_fence.runId = ? AND run_fence.generation = ? AND run_fence.ownerId = ?)`,
+		params: [
+			fence.runId,
+			fence.generation,
+			fence.ownerId
+		]
+	};
+}
+/** Throws `RunFenceConflictError` unless the check's fence is the run's current claim. */
+async function assertRunFence(db, { claimsTable, fence, operation }) {
+	const row = await db.executeQuery({
+		sql: `SELECT generation, ownerId FROM ${claimsTable} WHERE runId = ?`,
+		params: [fence.runId],
+		first: true
+	});
+	if (!(0, _mastra_core_storage.matchesRunFence)(row ? {
+		generation: Number(row.generation),
+		ownerId: String(row.ownerId)
+	} : null, fence)) throw new _mastra_core_storage.RunFenceConflictError(fence, operation);
+}
+/**
+* Runs one statement of a fenced write. With a check, `statement` must carry
+* `runFenceGuard(check)`. A guarded statement that changes no row either
+* found no target or was refused by its guard; re-reading the claim tells
+* which, and a refusal throws `RunFenceConflictError`.
+*
+* A write made of several statements stops at the first refused one, so a
+* takeover that lands between them leaves the earlier statements applied.
+* None of the refused writer's statements land after the takeover.
+*/
+async function executeFenced(db, check, { sql, params }) {
+	if (!check) {
+		await db.executeQuery({
+			sql,
+			params
+		});
+		return;
+	}
+	const rows = await db.executeQuery({
+		sql: `${sql} RETURNING 1 AS written`,
+		params
+	});
+	if (Array.isArray(rows) && rows.length === 0) await assertRunFence(db, check);
+}
+//#endregion
 //#region src/do/storage/db/index.ts
 var DODB = class extends _mastra_core_base.MastraBase {
 	sql;
@@ -517,10 +578,12 @@ var DODB = class extends _mastra_core_base.MastraBase {
 	* @param tableName The table to insert into
 	* @param records The records to insert
 	* @param conflictKeys The columns to use for conflict detection (defaults to ['id'])
+	* @param check Run fence every upsert must hold; a refused upsert throws and stops the batch
 	*/
-	async batchUpsert({ tableName, records, conflictKeys = ["id"] }) {
+	async batchUpsert({ tableName, records, conflictKeys = ["id"], check }) {
 		if (records.length === 0) return;
 		const fullTableName = this.getTableName(tableName);
+		const guard = runFenceGuard(check);
 		try {
 			const batchSize = 50;
 			for (let i = 0; i < records.length; i += batchSize) {
@@ -538,17 +601,15 @@ var DODB = class extends _mastra_core_base.MastraBase {
 							if (col !== "createdAt" && !conflictKeys.includes(col)) acc[col] = `excluded.${col}`;
 							return acc;
 						}, {});
-						const { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, conflictKeys, recordToUpsert).build();
-						await this.executeQuery({
-							sql,
-							params
-						});
+						const query = createSqlBuilder().insert(fullTableName, columns, values, conflictKeys, recordToUpsert, guard);
+						await executeFenced(this, check, query.build());
 					}
 				}
 				this.logger.debug(`Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`);
 			}
 			this.logger.debug(`Successfully batch upserted ${records.length} records into ${tableName}`);
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "BATCH_UPSERT", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -920,11 +981,76 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_MESSAGES],
 			ifNotExists: ["resourceId"]
 		});
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_MEMORY_RUN_FENCES]
+		});
 	}
 	async dangerouslyClearAll() {
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_MESSAGES });
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_THREADS });
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_RESOURCES });
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES });
+	}
+	supportsRunFencing() {
+		return true;
+	}
+	get #fencesTable() {
+		return this.#db.getTableName(_mastra_core_storage.TABLE_MEMORY_RUN_FENCES);
+	}
+	async raiseRunFence(fence) {
+		const table = this.#fencesTable;
+		try {
+			return (await this.#db.executeQuery({
+				sql: `INSERT INTO ${table} (runId, generation, ownerId) VALUES (?, ?, ?)
+          ON CONFLICT(runId) DO UPDATE SET generation = excluded.generation, ownerId = excluded.ownerId, retiredAt = NULL
+          WHERE excluded.generation > ${table}.generation
+            OR (excluded.generation = ${table}.generation AND excluded.ownerId = ${table}.ownerId)
+          RETURNING runId`,
+				params: [
+					fence.runId,
+					fence.generation,
+					fence.ownerId
+				]
+			})).length > 0;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "RAISE_RUN_FENCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { runId: fence.runId }
+			}, error);
+		}
+	}
+	async retireRunFence(fence) {
+		try {
+			return (await this.#db.executeQuery({
+				sql: `UPDATE ${this.#fencesTable} SET retiredAt = ${DB_NOW_MS}
+          WHERE runId = ? AND generation = ? AND ownerId = ?
+          RETURNING runId`,
+				params: [
+					fence.runId,
+					fence.generation,
+					fence.ownerId
+				]
+			})).length > 0;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "RETIRE_RUN_FENCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { runId: fence.runId }
+			}, error);
+		}
+	}
+	/** The check a write must pass: its own fence, otherwise the one in scope. */
+	#runFenceCheck(fence, operation) {
+		const resolved = (0, _mastra_core_storage.resolveRunFence)(this, fence);
+		return resolved && {
+			claimsTable: this.#fencesTable,
+			fence: resolved,
+			operation
+		};
 	}
 	async getResourceById({ resourceId }) {
 		const resource = await this.#db.load({
@@ -953,6 +1079,9 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 		}
 	}
 	async saveResource({ resource }) {
+		return this.#insertResource(resource, void 0);
+	}
+	async #insertResource(resource, check) {
 		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_RESOURCES);
 		const resourceToSave = {
 			id: resource.id,
@@ -964,19 +1093,17 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 		const processedRecord = await this.#db.processRecord(resourceToSave);
 		const columns = Object.keys(processedRecord);
 		const values = Object.values(processedRecord);
-		const { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, ["id"], {
+		const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], {
 			workingMemory: "excluded.workingMemory",
 			metadata: "excluded.metadata",
 			createdAt: "excluded.createdAt",
 			updatedAt: "excluded.updatedAt"
-		}).build();
+		}, runFenceGuard(check));
 		try {
-			await this.#db.executeQuery({
-				sql,
-				params
-			});
+			await executeFenced(this.#db, check, query.build());
 			return resource;
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "SAVE_RESOURCE", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -986,7 +1113,8 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
-	async updateResource({ resourceId, workingMemory, metadata }) {
+	async updateResource({ resourceId, workingMemory, metadata, fence }) {
+		const check = this.#runFenceCheck(fence, "updateResource");
 		const existingResource = await this.getResourceById({ resourceId });
 		if (!existingResource) {
 			const newResource = {
@@ -996,7 +1124,7 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 				createdAt: /* @__PURE__ */ new Date(),
 				updatedAt: /* @__PURE__ */ new Date()
 			};
-			return this.saveResource({ resource: newResource });
+			return this.#insertResource(newResource, check);
 		}
 		const updatedAt = /* @__PURE__ */ new Date();
 		const updatedResource = {
@@ -1019,14 +1147,14 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 			JSON.stringify(updatedResource.metadata),
 			updatedAt.toISOString()
 		];
-		const { sql, params } = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", resourceId).build();
+		const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", resourceId);
+		const guard = runFenceGuard(check);
+		if (guard) query.andWhere(guard.sql, ...guard.params);
 		try {
-			await this.#db.executeQuery({
-				sql,
-				params
-			});
+			await executeFenced(this.#db, check, query.build());
 			return updatedResource;
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "UPDATE_RESOURCE", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -1167,8 +1295,9 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 			};
 		}
 	}
-	async saveThread({ thread }) {
+	async saveThread({ thread, fence }) {
 		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_THREADS);
+		const check = this.#runFenceCheck(fence, "saveThread");
 		const threadToSave = {
 			id: thread.id,
 			resourceId: thread.resourceId,
@@ -1180,20 +1309,18 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 		const processedRecord = await this.#db.processRecord(threadToSave);
 		const columns = Object.keys(processedRecord);
 		const values = Object.values(processedRecord);
-		const { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, ["id"], {
+		const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], {
 			resourceId: "excluded.resourceId",
 			title: "excluded.title",
 			metadata: "excluded.metadata",
 			createdAt: "excluded.createdAt",
 			updatedAt: "excluded.updatedAt"
-		}).build();
+		}, runFenceGuard(check));
 		try {
-			await this.#db.executeQuery({
-				sql,
-				params
-			});
+			await executeFenced(this.#db, check, query.build());
 			return thread;
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "SAVE_THREAD", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -1203,7 +1330,8 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
-	async updateThread({ id, title, metadata }) {
+	async updateThread({ id, title, metadata, fence }) {
+		const check = this.#runFenceCheck(fence, "updateThread");
 		const thread = await this.getThreadById({ threadId: id });
 		try {
 			if (!thread) throw new Error(`Thread ${id} not found`);
@@ -1226,11 +1354,10 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 			}
 			columns.push("updatedAt");
 			values.push(updatedAt.toISOString());
-			const { sql, params } = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", id).build();
-			await this.#db.executeQuery({
-				sql,
-				params
-			});
+			const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", id);
+			const guard = runFenceGuard(check);
+			if (guard) query.andWhere(guard.sql, ...guard.params);
+			await executeFenced(this.#db, check, query.build());
 			return {
 				...thread,
 				title: updatedTitle,
@@ -1238,6 +1365,7 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 				updatedAt
 			};
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "UPDATE_THREAD", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -1274,6 +1402,7 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 	async saveMessages(args) {
 		const { messages } = args;
 		if (messages.length === 0) return { messages: [] };
+		const check = this.#runFenceCheck(args.fence, "saveMessages");
 		try {
 			const now = /* @__PURE__ */ new Date();
 			for (const [i, message] of messages.entries()) {
@@ -1299,16 +1428,24 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 					resourceId: message.resourceId
 				};
 			});
-			await Promise.all([this.#db.batchUpsert({
+			await this.#db.batchUpsert({
 				tableName: _mastra_core_storage.TABLE_MESSAGES,
-				records: messagesToInsert
-			}), ...uniqueThreadIds.map((tid) => this.#db.executeQuery({
-				sql: `UPDATE ${this.#db.getTableName(_mastra_core_storage.TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
-				params: [now.toISOString(), tid]
-			}))]);
+				records: messagesToInsert,
+				check
+			});
+			const guard = runFenceGuard(check);
+			for (const tid of uniqueThreadIds) await executeFenced(this.#db, check, {
+				sql: `UPDATE ${this.#db.getTableName(_mastra_core_storage.TABLE_THREADS)} SET updatedAt = ? WHERE id = ?${guard ? ` AND ${guard.sql}` : ""}`,
+				params: [
+					now.toISOString(),
+					tid,
+					...guard?.params ?? []
+				]
+			});
 			this.logger.debug(`Saved ${messages.length} messages`);
 			return { messages: new _mastra_core_agent.MessageList().add(messages, "memory").get.all.db() };
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "SAVE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -1584,6 +1721,8 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 		const { messages } = args;
 		this.logger.debug("Updating messages", { count: messages.length });
 		if (!messages.length) return [];
+		const check = this.#runFenceCheck(args.fence, "updateMessages");
+		const guard = runFenceGuard(check);
 		const messageIds = messages.map((m) => m.id);
 		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_MESSAGES);
 		const threadsTableName = this.#db.getTableName(_mastra_core_storage.TABLE_THREADS);
@@ -1628,7 +1767,7 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 			}
 			for (const msg of updatedMessages) {
 				const contentStr = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-				const { sql, params } = createSqlBuilder().update(fullTableName, [
+				const updateQuery = createSqlBuilder().update(fullTableName, [
 					"content",
 					"role",
 					"type"
@@ -1636,19 +1775,22 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 					contentStr,
 					msg.role,
 					msg.type
-				]).where("id = ?", msg.id).build();
-				await this.#db.executeQuery({
-					sql,
-					params
-				});
+				]).where("id = ?", msg.id);
+				if (guard) updateQuery.andWhere(guard.sql, ...guard.params);
+				await executeFenced(this.#db, check, updateQuery.build());
 			}
 			const threadIds = [...new Set(updatedMessages.map((m) => m.threadId))];
-			for (const tid of threadIds) await this.#db.executeQuery({
-				sql: `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id = ?`,
-				params: [now, tid]
+			for (const tid of threadIds) await executeFenced(this.#db, check, {
+				sql: `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id = ?${guard ? ` AND ${guard.sql}` : ""}`,
+				params: [
+					now,
+					tid,
+					...guard?.params ?? []
+				]
 			});
 			return new _mastra_core_agent.MessageList().add(updatedMessages, "memory").get.all.db();
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "UPDATE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -1658,17 +1800,19 @@ var MemoryStorageDO = class extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
-	async deleteMessages(messageIds) {
+	async deleteMessages(messageIds, options) {
 		if (messageIds.length === 0) return;
 		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_MESSAGES);
+		const check = this.#runFenceCheck(options?.fence, "deleteMessages");
 		try {
-			const sql = `DELETE FROM ${fullTableName} WHERE id IN (${messageIds.map(() => "?").join(",")})`;
-			await this.#db.executeQuery({
-				sql,
-				params: messageIds
-			});
+			const placeholders = messageIds.map(() => "?").join(",");
+			const query = createSqlBuilder().delete(fullTableName).where(`id IN (${placeholders})`, ...messageIds);
+			const guard = runFenceGuard(check);
+			if (guard) query.andWhere(guard.sql, ...guard.params);
+			await executeFenced(this.#db, check, query.build());
 			this.logger.debug(`Deleted ${messageIds.length} messages`);
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "DELETE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -1980,6 +2124,22 @@ var ScoresStorageDO = class extends _mastra_core_storage.ScoresStorage {
 };
 //#endregion
 //#region src/do/storage/domains/workflows/index.ts
+const RUN_OWNER_COLUMNS = `generation, ownerId, leaseExpiresAt, ${DB_NOW_MS} AS nowMs`;
+/**
+* A run's first generation is the database clock, so a run claimed again after
+* its ownership record was pruned still gets a higher generation than its fence.
+*/
+const FIRST_GENERATION = `MAX(1, ${DB_NOW_MS})`;
+function toRunOwnershipRecord(runId, row) {
+	const leaseExpiresAt = row.leaseExpiresAt === null ? null : Number(row.leaseExpiresAt);
+	return {
+		runId,
+		generation: Number(row.generation),
+		ownerId: String(row.ownerId),
+		leaseExpiresAt: leaseExpiresAt === null ? null : new Date(leaseExpiresAt),
+		live: leaseExpiresAt !== null && leaseExpiresAt > Number(row.nowMs)
+	};
+}
 var WorkflowsStorageDO = class extends _mastra_core_storage.WorkflowsStorage {
 	#db;
 	constructor(config) {
@@ -1994,9 +2154,148 @@ var WorkflowsStorageDO = class extends _mastra_core_storage.WorkflowsStorage {
 			tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT]
 		});
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS]
+		});
 	}
 	async dangerouslyClearAll() {
 		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT });
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS });
+	}
+	supportsRunFencing() {
+		return true;
+	}
+	get #ownersTable() {
+		return this.#db.getTableName(_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS);
+	}
+	#runFenceCheck(fence, runId, operation) {
+		const resolved = (0, _mastra_core_storage.resolveRunFence)(this, fence, runId);
+		return resolved && {
+			claimsTable: this.#ownersTable,
+			fence: resolved,
+			operation
+		};
+	}
+	async #readRunOwner(runId) {
+		const row = await this.#db.executeQuery({
+			sql: `SELECT ${RUN_OWNER_COLUMNS} FROM ${this.#ownersTable} WHERE runId = ?`,
+			params: [runId],
+			first: true
+		});
+		return row ? toRunOwnershipRecord(runId, row) : null;
+	}
+	#ownershipError(operation, runId, error) {
+		return new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", operation, "FAILED"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+			details: { runId }
+		}, error);
+	}
+	async claimRunOwnership({ runId, ownerId, leaseMs, force, expectedGeneration }) {
+		const notLive = `(leaseExpiresAt IS NULL OR leaseExpiresAt <= ${DB_NOW_MS})`;
+		let statement;
+		if (expectedGeneration === void 0) statement = {
+			sql: `INSERT INTO ${this.#ownersTable} (runId, generation, ownerId, leaseExpiresAt, updatedAt)
+          VALUES (?, ${FIRST_GENERATION}, ?, ${DB_NOW_MS} + ?, ${DB_NOW_MS})
+          ON CONFLICT(runId) DO UPDATE SET
+            generation = generation + 1,
+            ownerId = excluded.ownerId,
+            leaseExpiresAt = excluded.leaseExpiresAt,
+            updatedAt = excluded.updatedAt
+          ${force ? "" : `WHERE ${notLive}`}`,
+			params: [
+				runId,
+				ownerId,
+				leaseMs
+			]
+		};
+		else if (expectedGeneration === 0) statement = {
+			sql: `INSERT INTO ${this.#ownersTable} (runId, generation, ownerId, leaseExpiresAt, updatedAt)
+          VALUES (?, ${FIRST_GENERATION}, ?, ${DB_NOW_MS} + ?, ${DB_NOW_MS})
+          ON CONFLICT(runId) DO NOTHING`,
+			params: [
+				runId,
+				ownerId,
+				leaseMs
+			]
+		};
+		else statement = {
+			sql: `UPDATE ${this.#ownersTable}
+          SET generation = generation + 1, ownerId = ?, leaseExpiresAt = ${DB_NOW_MS} + ?, updatedAt = ${DB_NOW_MS}
+          WHERE runId = ? AND generation = ?${force ? "" : ` AND ${notLive}`}`,
+			params: [
+				ownerId,
+				leaseMs,
+				runId,
+				expectedGeneration
+			]
+		};
+		try {
+			const claimed = (await this.#db.executeQuery({
+				sql: `${statement.sql} RETURNING ${RUN_OWNER_COLUMNS}`,
+				params: statement.params
+			}))[0];
+			if (claimed) return {
+				acquired: true,
+				record: toRunOwnershipRecord(runId, claimed)
+			};
+			return {
+				acquired: false,
+				record: await this.#readRunOwner(runId)
+			};
+		} catch (error) {
+			throw this.#ownershipError("CLAIM_RUN_OWNERSHIP", runId, error);
+		}
+	}
+	async renewRunOwnership({ leaseMs, ...fence }) {
+		try {
+			const renewed = (await this.#db.executeQuery({
+				sql: `UPDATE ${this.#ownersTable} SET leaseExpiresAt = ${DB_NOW_MS} + ?, updatedAt = ${DB_NOW_MS}
+          WHERE runId = ? AND generation = ? AND ownerId = ? AND leaseExpiresAt IS NOT NULL
+          RETURNING ${RUN_OWNER_COLUMNS}`,
+				params: [
+					leaseMs,
+					fence.runId,
+					fence.generation,
+					fence.ownerId
+				]
+			}))[0];
+			if (renewed) return {
+				renewed: true,
+				record: toRunOwnershipRecord(fence.runId, renewed)
+			};
+			return {
+				renewed: false,
+				record: await this.#readRunOwner(fence.runId)
+			};
+		} catch (error) {
+			throw this.#ownershipError("RENEW_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async releaseRunOwnership(fence) {
+		try {
+			return (await this.#db.executeQuery({
+				sql: `UPDATE ${this.#ownersTable} SET leaseExpiresAt = NULL, updatedAt = ${DB_NOW_MS}
+          WHERE runId = ? AND generation = ? AND ownerId = ?
+          RETURNING runId`,
+				params: [
+					fence.runId,
+					fence.generation,
+					fence.ownerId
+				]
+			})).length > 0;
+		} catch (error) {
+			throw this.#ownershipError("RELEASE_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async getRunOwnership({ runId }) {
+		try {
+			return await this.#readRunOwner(runId);
+		} catch (error) {
+			throw this.#ownershipError("GET_RUN_OWNERSHIP", runId, error);
+		}
 	}
 	updateWorkflowResults({}) {
 		throw new Error("Method not implemented.");
@@ -2004,9 +2303,10 @@ var WorkflowsStorageDO = class extends _mastra_core_storage.WorkflowsStorage {
 	updateWorkflowState({}) {
 		throw new Error("Method not implemented.");
 	}
-	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt }) {
+	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt, fence }) {
 		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const check = this.#runFenceCheck(fence, runId, "persistWorkflowSnapshot");
 		const currentSnapshot = await this.#db.load({
 			tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 			keys: {
@@ -2039,13 +2339,11 @@ var WorkflowsStorageDO = class extends _mastra_core_storage.WorkflowsStorage {
 			workflowName,
 			runId
 		});
-		const { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, ["workflow_name", "run_id"], updateMap).build();
+		const query = createSqlBuilder().insert(fullTableName, columns, values, ["workflow_name", "run_id"], updateMap, runFenceGuard(check));
 		try {
-			await this.#db.executeQuery({
-				sql,
-				params
-			});
+			await executeFenced(this.#db, check, query.build());
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -2200,16 +2498,16 @@ var WorkflowsStorageDO = class extends _mastra_core_storage.WorkflowsStorage {
 			}, error);
 		}
 	}
-	async deleteWorkflowRunById({ runId, workflowName }) {
+	async deleteWorkflowRunById({ runId, workflowName, fence }) {
 		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
+		const check = this.#runFenceCheck(fence, runId, "deleteWorkflowRunById");
 		try {
-			const sql = `DELETE FROM ${fullTableName} WHERE workflow_name = ? AND run_id = ?`;
-			const params = [workflowName, runId];
-			await this.#db.executeQuery({
-				sql,
-				params
-			});
+			const query = createSqlBuilder().delete(fullTableName).where("workflow_name = ?", workflowName).andWhere("run_id = ?", runId);
+			const guard = runFenceGuard(check);
+			if (guard) query.andWhere(guard.sql, ...guard.params);
+			await executeFenced(this.#db, check, query.build());
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_DO", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -2346,4 +2644,4 @@ Object.defineProperty(exports, "WorkflowsStorageDO", {
 	}
 });
 
-//# sourceMappingURL=do-zOdIsGy9.cjs.map
+//# sourceMappingURL=do-Uemcag89.cjs.map