@mastra/pg 1.22.0-alpha.0 → 1.22.0-alpha.3

package/dist/index.js

@@ -541,11 +541,22 @@ function buildFilterQuery(filter, minScore, topK) {
 }
 //#endregion
 //#region src/vector/index.ts
-const MAX_UPSERT_ROWS_PER_STATEMENT = Math.floor(65535 / 3);
+const DEFAULT_NAMESPACE = "default";
+const MAX_UPSERT_ROWS_PER_STATEMENT = Math.floor(65535 / 4);
 var PgVector = class extends MastraVector {
 	pool;
+	/**
+	* Cache for the public `getIndexInfo()`. Holds the in-flight promise rather than the
+	* resolved value so concurrent callers on a cold cache share a single round trip.
+	*/
 	describeIndexCache = /* @__PURE__ */ new Map();
+	/**
+	* Cache for the catalog-only index metadata used by the internal hot paths
+	* (cache warmup, query, upsert, updateVector, setupIndex). Also memoizes the promise.
+	*/
+	indexMetadataCache = /* @__PURE__ */ new Map();
 	createdIndexes = /* @__PURE__ */ new Map();
+	namespaceReadyIndexes = /* @__PURE__ */ new Set();
 	indexVectorTypes = /* @__PURE__ */ new Map();
 	mutexesByName = /* @__PURE__ */ new Map();
 	schema;
@@ -601,7 +612,7 @@ var PgVector = class extends MastraVector {
 				try {
 					const existingIndexes = await this.listIndexes();
 					await Promise.all(existingIndexes.map(async (indexName) => {
-						const info = await this.getIndexInfo({ indexName });
+						const info = await this.getIndexMetadata({ indexName });
 						const key = await this.getIndexCacheKey({
 							indexName,
 							metric: info.metric,
@@ -774,20 +785,76 @@ var PgVector = class extends MastraVector {
 		const quotedVectorName = `"${parsedIndexName}_vector_idx"`;
 		return {
 			tableName: quotedSchemaName ? `${quotedSchemaName}.${quotedIndexName}` : quotedIndexName,
-			vectorIndexName: quotedVectorName
+			vectorIndexName: quotedVectorName,
+			parsedIndexName
 		};
 	}
 	getSchemaName() {
 		return this.schema ? `"${parseSqlIdentifier(this.schema, "schema name")}"` : void 0;
 	}
+	async ensureNamespaceSchema(indexName, client) {
+		const { tableName, parsedIndexName } = this.getTableName(indexName);
+		const schemaName = this.schema ? parseSqlIdentifier(this.schema, "schema name") : "public";
+		if ((await client.query(`SELECT 1
+       FROM information_schema.columns
+       WHERE table_schema = $1 AND table_name = $2 AND column_name = 'vector_id'`, [schemaName, parsedIndexName])).rowCount === 0) return;
+		await client.query(`ALTER TABLE ${tableName} ADD COLUMN IF NOT EXISTS namespace VARCHAR(255) NOT NULL DEFAULT '${DEFAULT_NAMESPACE}'`);
+		const legacyConstraints = await client.query(`SELECT c.conname
+       FROM pg_constraint c
+       JOIN pg_class t ON t.oid = c.conrelid
+       JOIN pg_namespace n ON n.oid = t.relnamespace
+       WHERE n.nspname = $1
+         AND t.relname = $2
+         AND c.contype = 'u'
+         AND pg_get_constraintdef(c.oid) = 'UNIQUE (vector_id)'`, [schemaName, parsedIndexName]);
+		for (const { conname } of legacyConstraints.rows) {
+			const parsedConstraintName = parseSqlIdentifier(conname, "constraint name");
+			await client.query(`ALTER TABLE ${tableName} DROP CONSTRAINT "${parsedConstraintName}"`);
+		}
+		const namespaceIndexName = parseSqlIdentifier(`${parsedIndexName}_namespace_vector_id_idx`, "index name");
+		await client.query(`CREATE UNIQUE INDEX IF NOT EXISTS "${namespaceIndexName}" ON ${tableName} (namespace, vector_id)`);
+	}
 	transformFilter(filter) {
 		return new PGFilterTranslator().translate(filter);
 	}
+	/**
+	* Cached variant of {@link describeIndex}, including the row count.
+	*
+	* Internal code paths do not use this - they use the catalog-only
+	* {@link getIndexMetadata}, which never scans the table.
+	*/
 	async getIndexInfo({ indexName }) {
-		if (!this.describeIndexCache.has(indexName)) this.describeIndexCache.set(indexName, await this.describeIndex({ indexName }));
-		return this.describeIndexCache.get(indexName);
+		return this.memoize(this.describeIndexCache, indexName, () => this.describeIndex({ indexName }));
+	}
+	/**
+	* Cached index metadata read from the Postgres catalog only.
+	*
+	* This is what every internal caller needs: none of them read `count`, and paying for
+	* `SELECT COUNT(*)` on a large index costs a full heap scan per call.
+	*/
+	getIndexMetadata({ indexName }) {
+		return this.memoize(this.indexMetadataCache, indexName, () => this.describeIndexMetadata({ indexName }));
+	}
+	/**
+	* Stores the in-flight promise in `cache` so concurrent callers on a cold cache share one
+	* round trip, and drops the entry if it rejects so a transient failure is not cached forever.
+	*/
+	memoize(cache, key, load) {
+		const cached = cache.get(key);
+		if (cached) return cached;
+		const pending = load();
+		cache.set(key, pending);
+		pending.catch(() => {
+			if (cache.get(key) === pending) cache.delete(key);
+		});
+		return pending;
+	}
+	/** Drops every cached view of an index, e.g. after its index definition or table changed. */
+	invalidateIndexCaches(indexName) {
+		this.describeIndexCache.delete(indexName);
+		this.indexMetadataCache.delete(indexName);
 	}
-	async query({ indexName, queryVector, topK = 10, filter, includeVector = false, minScore = -1, ef, probes }) {
+	async query({ indexName, queryVector, topK = 10, filter, includeVector = false, minScore = -1, ef, probes, namespace = DEFAULT_NAMESPACE }) {
 		try {
 			validateTopK("PG", topK);
 			if (queryVector !== void 0) {
@@ -808,16 +875,23 @@ var PgVector = class extends MastraVector {
 			try {
 				const { sql: filterQuery, values: filterValues } = buildDeleteFilterQuery(this.transformFilter(filter));
 				const { tableName } = this.getTableName(indexName);
+				const filterClause = filterQuery.trim().replace(/^WHERE\s+/i, "");
+				const namespaceParam = filterValues.length + 1;
 				const query = `
           SELECT
             vector_id as id,
             metadata
             ${includeVector ? ", embedding" : ""}
           FROM ${tableName}
-          ${filterQuery}
+          WHERE namespace = $${namespaceParam}
+          ${filterClause ? `AND (${filterClause})` : ""}
           ORDER BY vector_id
-          LIMIT $${filterValues.length + 1}`;
-				return (await client.query(query, [...filterValues, topK])).rows.map(({ id, metadata, embedding }) => ({
+          LIMIT $${namespaceParam + 1}`;
+				return (await client.query(query, [
+					...filterValues,
+					namespace,
+					topK
+				])).rows.map(({ id, metadata, embedding }) => ({
 					id,
 					score: 0,
 					metadata,
@@ -841,7 +915,7 @@ var PgVector = class extends MastraVector {
 			await this.ensureSearchPath(client);
 			await client.query("BEGIN");
 			const { sql: filterQuery, values: filterValues } = buildFilterQuery(this.transformFilter(filter), minScore, topK);
-			const indexInfo = await this.getIndexInfo({ indexName });
+			const indexInfo = await this.getIndexMetadata({ indexName });
 			const metric = indexInfo.metric ?? "cosine";
 			const ops = this.getVectorOps(indexInfo.vectorType, metric);
 			const vectorStr = ops.formatVector(queryVector, indexInfo.dimension);
@@ -849,14 +923,18 @@ var PgVector = class extends MastraVector {
 				const calculatedEf = ef ?? Math.max(topK, (indexInfo?.config?.m ?? 16) * topK);
 				const searchEf = Math.min(1e3, Math.max(1, calculatedEf));
 				await client.query(`SET LOCAL hnsw.ef_search = ${searchEf}`);
+				await client.query(`SET LOCAL hnsw.iterative_scan = strict_order`);
 			}
 			if (indexInfo.type === "ivfflat" && probes) await client.query(`SET LOCAL ivfflat.probes = ${probes}`);
 			const { tableName } = this.getTableName(indexName);
 			const qualifiedVectorType = this.getVectorTypeName(indexInfo.vectorType, indexInfo.dimension);
 			const distanceExpr = `embedding ${ops.distanceOperator} '${vectorStr}'::${qualifiedVectorType}`;
 			const scoreExpr = ops.scoreExpr(distanceExpr);
-			const hasFilter = filterQuery.trim().length > 0;
-			const query = indexInfo.type === "hnsw" && !hasFilter && minScore <= 0 ? `
+			const filterClause = filterQuery.trim().replace(/^WHERE\s+/i, "");
+			const hasFilter = filterClause.length > 0;
+			const useIndexedOrder = indexInfo.type === "hnsw" && !hasFilter && minScore <= 0;
+			const namespaceParam = filterValues.length + 1;
+			const query = useIndexedOrder ? `
         WITH vector_scores AS (
           SELECT
             vector_id as id,
@@ -864,6 +942,7 @@ var PgVector = class extends MastraVector {
             metadata
             ${includeVector ? ", embedding" : ""}
           FROM ${tableName}
+          WHERE namespace = $${namespaceParam}
           ORDER BY ${distanceExpr}
           LIMIT $2
         )
@@ -878,14 +957,15 @@ var PgVector = class extends MastraVector {
             metadata
             ${includeVector ? ", embedding" : ""}
           FROM ${tableName}
-          ${filterQuery}
+          WHERE namespace = $${namespaceParam}
+          ${filterClause ? `AND (${filterClause})` : ""}
         )
         SELECT *
         FROM vector_scores
         WHERE score > $1
         ORDER BY score DESC
         LIMIT $2`;
-			const result = await client.query(query, filterValues);
+			const result = await client.query(query, [...filterValues, namespace]);
 			await client.query("COMMIT");
 			return result.rows.map(({ id, score, metadata, embedding }) => ({
 				id,
@@ -907,7 +987,7 @@ var PgVector = class extends MastraVector {
 			client.release();
 		}
 	}
-	async upsert({ indexName, vectors, metadata, ids, deleteFilter }) {
+	async upsert({ indexName, vectors, metadata, ids, deleteFilter, namespace = DEFAULT_NAMESPACE }) {
 		validateUpsertInput("PG", vectors, metadata, ids);
 		const { tableName } = this.getTableName(indexName);
 		const client = await this.pool.connect();
@@ -922,8 +1002,8 @@ var PgVector = class extends MastraVector {
 				const { sql: filterQuery, values: filterValues } = buildDeleteFilterQuery(this.transformFilter(deleteFilter));
 				const whereClause = filterQuery.trim().replace(/^WHERE\s+/i, "");
 				if (whereClause) {
-					const deleteQuery = `DELETE FROM ${tableName} WHERE ${whereClause}`;
-					const result = await client.query(deleteQuery, filterValues);
+					const deleteQuery = `DELETE FROM ${tableName} WHERE namespace = $${filterValues.length + 1} AND (${whereClause})`;
+					const result = await client.query(deleteQuery, [...filterValues, namespace]);
 					this.logger?.debug(`Deleted ${result.rowCount || 0} vectors before upsert`, {
 						indexName,
 						deletedCount: result.rowCount || 0
@@ -931,15 +1011,15 @@ var PgVector = class extends MastraVector {
 				}
 			}
 			const vectorIds = ids || vectors.map(() => crypto.randomUUID());
-			const indexInfo = await this.getIndexInfo({ indexName });
+			const indexInfo = await this.getIndexMetadata({ indexName });
 			const qualifiedVectorType = this.getVectorTypeName(indexInfo.vectorType, indexInfo.dimension);
 			const ops = this.getVectorOps(indexInfo.vectorType, indexInfo.metric ?? "cosine");
 			if (new Set(vectorIds).size !== vectorIds.length) for (let i = 0; i < vectors.length; i++) {
 				const vectorStr = ops.formatVector(vectors[i], indexInfo.dimension);
 				const query = `
-            INSERT INTO ${tableName} (vector_id, embedding, metadata)
-            VALUES ($1, $2::${qualifiedVectorType}, $3::jsonb)
-            ON CONFLICT (vector_id)
+            INSERT INTO ${tableName} (vector_id, embedding, metadata, namespace)
+            VALUES ($1, $2::${qualifiedVectorType}, $3::jsonb, $4)
+            ON CONFLICT (namespace, vector_id)
             DO UPDATE SET
               embedding = $2::${qualifiedVectorType},
               metadata = $3::jsonb
@@ -947,7 +1027,8 @@ var PgVector = class extends MastraVector {
 				await client.query(query, [
 					vectorIds[i],
 					vectorStr,
-					JSON.stringify(metadata?.[i] || {})
+					JSON.stringify(metadata?.[i] || {}),
+					namespace
 				]);
 			}
 			else for (let start = 0; start < vectors.length; start += MAX_UPSERT_ROWS_PER_STATEMENT) {
@@ -956,13 +1037,13 @@ var PgVector = class extends MastraVector {
 				const values = [];
 				for (let i = start; i < end; i++) {
 					const base = values.length;
-					rows.push(`($${base + 1}, $${base + 2}::${qualifiedVectorType}, $${base + 3}::jsonb)`);
-					values.push(vectorIds[i], ops.formatVector(vectors[i], indexInfo.dimension), JSON.stringify(metadata?.[i] || {}));
+					rows.push(`($${base + 1}, $${base + 2}::${qualifiedVectorType}, $${base + 3}::jsonb, $${base + 4})`);
+					values.push(vectorIds[i], ops.formatVector(vectors[i], indexInfo.dimension), JSON.stringify(metadata?.[i] || {}), namespace);
 				}
 				const query = `
-            INSERT INTO ${tableName} (vector_id, embedding, metadata)
+            INSERT INTO ${tableName} (vector_id, embedding, metadata, namespace)
             VALUES ${rows.join(", ")}
-            ON CONFLICT (vector_id)
+            ON CONFLICT (namespace, vector_id)
             DO UPDATE SET
               embedding = EXCLUDED.embedding,
               metadata = EXCLUDED.metadata
@@ -1082,9 +1163,9 @@ var PgVector = class extends MastraVector {
 			vectorType,
 			metadataIndexes
 		});
-		if (this.cachedIndexExists(indexName, indexCacheKey)) return;
+		if (this.cachedIndexExists(indexName, indexCacheKey) && this.namespaceReadyIndexes.has(indexName)) return;
 		await this.getMutexByName(`create-${indexName}`).runExclusive(async () => {
-			if (this.cachedIndexExists(indexName, indexCacheKey)) return;
+			if (this.cachedIndexExists(indexName, indexCacheKey) && this.namespaceReadyIndexes.has(indexName)) return;
 			const client = await this.pool.connect();
 			try {
 				await this.setupSchema(client);
@@ -1128,12 +1209,15 @@ var PgVector = class extends MastraVector {
 				await client.query(`
           CREATE TABLE IF NOT EXISTS ${tableName} (
             id SERIAL PRIMARY KEY,
-            vector_id TEXT UNIQUE NOT NULL,
+            vector_id TEXT NOT NULL,
             embedding ${qualifiedVectorType}(${dimension}),
-            metadata JSONB DEFAULT '{}'::jsonb
+            metadata JSONB DEFAULT '{}'::jsonb,
+            namespace VARCHAR(255) NOT NULL DEFAULT '${DEFAULT_NAMESPACE}'
           );
         `);
+				await this.ensureNamespaceSchema(indexName, client);
 				this.createdIndexes.set(indexName, indexCacheKey);
+				this.namespaceReadyIndexes.add(indexName);
 				this.indexVectorTypes.set(indexName, vectorType);
 				if (buildIndex) await this.setupIndex({
 					indexName,
@@ -1144,6 +1228,7 @@ var PgVector = class extends MastraVector {
 				if (metadataIndexes?.length) await this.createMetadataIndexes(tableName, indexName, metadataIndexes);
 			} catch (error) {
 				this.createdIndexes.delete(indexName);
+				this.namespaceReadyIndexes.delete(indexName);
 				this.indexVectorTypes.delete(indexName);
 				throw error;
 			} finally {
@@ -1214,7 +1299,7 @@ var PgVector = class extends MastraVector {
 			let existingIndexInfo = null;
 			let dimension = 0;
 			try {
-				existingIndexInfo = await this.getIndexInfo({ indexName });
+				existingIndexInfo = await this.getIndexMetadata({ indexName });
 				dimension = existingIndexInfo.dimension;
 				if (isConfigEmpty && existingIndexInfo.metric === metric) if (existingIndexInfo.type === "flat") this.logger?.debug(`No index exists for ${vectorIndexName}, will create default ivfflat index`);
 				else {
@@ -1249,12 +1334,12 @@ var PgVector = class extends MastraVector {
 				}
 				this.logger?.info(`Index ${vectorIndexName} configuration changed, rebuilding index`);
 				await client.query(`DROP INDEX IF EXISTS ${vectorIndexName}`);
-				this.describeIndexCache.delete(indexName);
+				this.invalidateIndexCaches(indexName);
 			} catch {
 				this.logger?.debug(`Index ${indexName} doesn't exist yet, will create it`);
 			}
 			if (indexType === "flat") {
-				this.describeIndexCache.delete(indexName);
+				this.invalidateIndexCaches(indexName);
 				return;
 			}
 			await this.ensureSearchPath(client);
@@ -1404,6 +1489,19 @@ var PgVector = class extends MastraVector {
 	* @returns A promise that resolves to the index statistics including dimension, count and metric
 	*/
 	async describeIndex({ indexName }) {
+		const metadata = await this.describeIndexMetadata({ indexName });
+		const count = await this.countIndexRows({ indexName });
+		return {
+			...metadata,
+			count
+		};
+	}
+	/**
+	* Reads the index metadata that lives in the Postgres catalog. Unlike
+	* {@link describeIndex} it issues no `COUNT(*)`, so its cost does not grow with the
+	* number of rows in the table.
+	*/
+	async describeIndexMetadata({ indexName }) {
 		const client = await this.pool.connect();
 		try {
 			const { tableName } = this.getTableName(indexName);
@@ -1423,10 +1521,6 @@ var PgVector = class extends MastraVector {
                 FROM pg_attribute
                 WHERE attrelid = $1::regclass
                 AND attname = 'embedding';
-            `;
-			const countQuery = `
-                SELECT COUNT(*) as count
-                FROM ${tableName};
             `;
 			const indexQuery = `
             SELECT
@@ -1442,7 +1536,6 @@ var PgVector = class extends MastraVector {
             AND n.nspname = $2;
             `;
 			const dimResult = await client.query(dimensionQuery, [tableName]);
-			const countResult = await client.query(countQuery);
 			const { index_method, index_def, operator_class } = (await client.query(indexQuery, [`${indexName}_vector_idx`, this.schema || "public"])).rows[0] || {
 				index_method: "flat",
 				index_def: "",
@@ -1461,7 +1554,6 @@ var PgVector = class extends MastraVector {
 			}
 			return {
 				dimension: dimResult.rows[0].dimension,
-				count: parseInt(countResult.rows[0].count),
 				metric,
 				type: index_method,
 				vectorType,
@@ -1481,14 +1573,41 @@ var PgVector = class extends MastraVector {
 			client.release();
 		}
 	}
+	/**
+	* Exact row count for an index. This is a full scan of the table, so it is only issued
+	* for the public {@link describeIndex}, never from an internal code path.
+	*/
+	async countIndexRows({ indexName }) {
+		const client = await this.pool.connect();
+		try {
+			const { tableName } = this.getTableName(indexName);
+			const countResult = await client.query(`
+                SELECT COUNT(*) as count
+                FROM ${tableName};
+            `);
+			return parseInt(countResult.rows[0].count);
+		} catch (e) {
+			const mastraError = new MastraError({
+				id: createVectorErrorId("PG", "DESCRIBE_INDEX", "FAILED"),
+				domain: ErrorDomain.MASTRA_VECTOR,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, e);
+			this.logger?.trackException(mastraError);
+			throw mastraError;
+		} finally {
+			client.release();
+		}
+	}
 	async deleteIndex({ indexName }) {
 		const client = await this.pool.connect();
 		try {
 			const { tableName } = this.getTableName(indexName);
 			await client.query(`DROP TABLE IF EXISTS ${tableName} CASCADE`);
 			this.createdIndexes.delete(indexName);
+			this.namespaceReadyIndexes.delete(indexName);
 			this.indexVectorTypes.delete(indexName);
-			this.describeIndexCache.delete(indexName);
+			this.invalidateIndexCaches(indexName);
 		} catch (error) {
 			await client.query("ROLLBACK");
 			const mastraError = new MastraError({
@@ -1538,7 +1657,7 @@ var PgVector = class extends MastraVector {
 	* @returns A promise that resolves when the update is complete.
 	* @throws Will throw an error if no updates are provided or if the update operation fails.
 	*/
-	async updateVector({ indexName, id, filter, update }) {
+	async updateVector({ indexName, id, filter, update, namespace = DEFAULT_NAMESPACE }) {
 		let client;
 		try {
 			if (!update.vector && !update.metadata) throw new Error("No updates provided");
@@ -1559,7 +1678,7 @@ var PgVector = class extends MastraVector {
 			client = await this.pool.connect();
 			await this.ensureSearchPath(client);
 			const { tableName } = this.getTableName(indexName);
-			const indexInfo = await this.getIndexInfo({ indexName });
+			const indexInfo = await this.getIndexMetadata({ indexName });
 			const qualifiedVectorType = this.getVectorTypeName(indexInfo.vectorType, indexInfo.dimension);
 			const ops = this.getVectorOps(indexInfo.vectorType, indexInfo.metric ?? "cosine");
 			let updateParts = [];
@@ -1578,8 +1697,11 @@ var PgVector = class extends MastraVector {
 			if (updateParts.length === 0) return;
 			let whereClause;
 			let whereValues;
+			const namespaceIndex = valueIndex;
+			values.push(namespace);
+			valueIndex++;
 			if (id) {
-				whereClause = `vector_id = $${valueIndex}`;
+				whereClause = `namespace = $${namespaceIndex} AND vector_id = $${valueIndex}`;
 				whereValues = [id];
 			} else {
 				if (!filter || Object.keys(filter).length === 0) throw new MastraError({
@@ -1604,6 +1726,7 @@ var PgVector = class extends MastraVector {
 				whereClause = whereClause.replace(/\$(\d+)/g, (match, num) => {
 					return `$${parseInt(num) + valueIndex - 1}`;
 				});
+				whereClause = `namespace = $${namespaceIndex} AND (${whereClause})`;
 				whereValues = filterValues;
 			}
 			const query = `
@@ -1643,16 +1766,16 @@ var PgVector = class extends MastraVector {
 	* @returns A promise that resolves when the deletion is complete.
 	* @throws Will throw an error if the deletion operation fails.
 	*/
-	async deleteVector({ indexName, id }) {
+	async deleteVector({ indexName, id, namespace = DEFAULT_NAMESPACE }) {
 		let client;
 		try {
 			client = await this.pool.connect();
 			const { tableName } = this.getTableName(indexName);
 			const query = `
         DELETE FROM ${tableName}
-        WHERE vector_id = $1
+        WHERE vector_id = $1 AND namespace = $2
       `;
-			await client.query(query, [id]);
+			await client.query(query, [id, namespace]);
 		} catch (error) {
 			const mastraError = new MastraError({
 				id: createVectorErrorId("PG", "DELETE_VECTOR", "FAILED"),
@@ -1676,14 +1799,15 @@ var PgVector = class extends MastraVector {
 	* @returns A promise that resolves when the deletion is complete.
 	* @throws Will throw an error if the deletion operation fails.
 	*/
-	async deleteVectors({ indexName, filter, ids }) {
+	async deleteVectors({ indexName, filter, ids, namespace }) {
 		let client;
+		const effectiveNamespace = namespace ?? DEFAULT_NAMESPACE;
 		try {
 			client = await this.pool.connect();
 			const { tableName } = this.getTableName(indexName);
-			if (!filter && !ids) throw new MastraError({
+			if (!filter && !ids && namespace === void 0) throw new MastraError({
 				id: createVectorErrorId("PG", "DELETE_VECTORS", "NO_TARGET"),
-				text: "Either filter or ids must be provided",
+				text: "Either filter or ids must be provided, unless an explicit namespace is used",
 				domain: ErrorDomain.MASTRA_VECTOR,
 				category: ErrorCategory.USER,
 				details: { indexName }
@@ -1705,9 +1829,9 @@ var PgVector = class extends MastraVector {
 					category: ErrorCategory.USER,
 					details: { indexName }
 				});
-				query = `DELETE FROM ${tableName} WHERE vector_id IN (${ids.map((_, i) => `$${i + 1}`).join(", ")})`;
-				values = ids;
-			} else {
+				query = `DELETE FROM ${tableName} WHERE vector_id IN (${ids.map((_, i) => `$${i + 1}`).join(", ")}) AND namespace = $${ids.length + 1}`;
+				values = [...ids, effectiveNamespace];
+			} else if (filter) {
 				if (!filter || Object.keys(filter).length === 0) throw new MastraError({
 					id: createVectorErrorId("PG", "DELETE_VECTORS", "EMPTY_FILTER"),
 					text: "Cannot delete with empty filter. Use deleteIndex to delete all vectors.",
@@ -1727,8 +1851,11 @@ var PgVector = class extends MastraVector {
 						filter: JSON.stringify(filter)
 					}
 				});
-				query = `DELETE FROM ${tableName} WHERE ${whereClause}`;
-				values = filterValues;
+				query = `DELETE FROM ${tableName} WHERE namespace = $${filterValues.length + 1} AND (${whereClause})`;
+				values = [...filterValues, effectiveNamespace];
+			} else {
+				query = `DELETE FROM ${tableName} WHERE namespace = $1`;
+				values = [effectiveNamespace];
 			}
 			const result = await client.query(query, values);
 			this.logger?.info(`Deleted ${result.rowCount || 0} vectors from ${indexName}`, {
@@ -13567,6 +13694,11 @@ const SPAN_EVENT_COLUMNS = [
 		type: "boolean",
 		defaultSql: "false"
 	},
+	{
+		name: "isPending",
+		type: "boolean",
+		defaultSql: "false"
+	},
 	{
 		name: "startedAt",
 		type: "timestamptz"
@@ -13863,6 +13995,7 @@ const SPAN_LIGHT_SELECT_COLUMN_NAMES = [
 	"spanType",
 	"error",
 	"isEvent",
+	"isPending",
 	"startedAt",
 	"endedAt"
 ];
@@ -14257,6 +14390,26 @@ function allTableDDL(schema, mode) {
 		discoveryTableDDL(schema)
 	];
 }
+/**
+* Additive column migrations for tables created by an older version of this
+* schema. `CREATE TABLE IF NOT EXISTS` is a no-op on an existing table, so new
+* columns have to be added out of band.
+*
+* `ALTER TABLE` takes an AccessExclusiveLock on the partitioned parent, so
+* callers must check {@link columnExistsSQL} first and only run the statement
+* when the column is genuinely missing. On Postgres 11+ the non-volatile
+* default does not rewrite the table, and the ALTER cascades to partitions.
+*/
+function additiveColumns(schema) {
+	return [{
+		table: TABLE_SPAN_EVENTS,
+		column: "isPending",
+		ddl: `ALTER TABLE ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} ADD COLUMN IF NOT EXISTS "isPending" boolean NOT NULL DEFAULT false`
+	}];
+}
+/** Existence probe for an additive column. Params: schema, table, column. */
+const columnExistsSQL = `SELECT 1 FROM information_schema.columns
+   WHERE table_schema = $1 AND table_name = $2 AND column_name = $3`;
 /** Index CREATEs. Safe to run repeatedly. */
 function allIndexDDL(schema) {
 	return tableIndexes().map((spec) => indexDDL(schema, spec));
@@ -14645,6 +14798,7 @@ function commonContextToRow(record) {
 	};
 }
 function spanRecordToRow(span) {
+	const isPending = !span.isEvent && span.endedAt == null;
 	const endedAt = span.isEvent ? span.startedAt : span.endedAt ?? span.startedAt;
 	const metadata = span.metadata ?? null;
 	return {
@@ -14655,6 +14809,7 @@ function spanRecordToRow(span) {
 		name: span.name,
 		spanType: span.spanType,
 		isEvent: Boolean(span.isEvent),
+		isPending,
 		startedAt: toIsoOrDate(span.startedAt),
 		endedAt: toIsoOrDate(endedAt),
 		tags: normalizeTags(span.tags),
@@ -14669,9 +14824,19 @@ function spanRecordToRow(span) {
 		requestContext: jsonField(span.requestContext)
 	};
 }
+/**
+* Recover a span's real `endedAt` from its row. A pending row carries a
+* synthesized `endedAt` (a copy of `startedAt`) because the column is part of
+* the primary key; callers must see null so the span reads as still running.
+*/
+function spanRowEndedAt(row, startedAt) {
+	if (row.isEvent) return startedAt;
+	if (row.isPending) return null;
+	return toDateOrNull(row.endedAt);
+}
 function rowToSpanRecord(row) {
 	const startedAt = toDate(row.startedAt);
-	const endedAt = row.isEvent ? startedAt : toDateOrNull(row.endedAt);
+	const endedAt = spanRowEndedAt(row, startedAt);
 	const error = parsedJson(row.error);
 	const { executionSource, ...ctx } = rowToCommonContext(row);
 	return {
@@ -14705,7 +14870,7 @@ function rowToSpanRecord(row) {
 */
 function rowToLightSpanRecord(row) {
 	const startedAt = toDate(row.startedAt);
-	const endedAt = row.isEvent ? startedAt : toDateOrNull(row.endedAt);
+	const endedAt = spanRowEndedAt(row, startedAt);
 	return {
 		traceId: row.traceId,
 		spanId: row.spanId,
@@ -15236,22 +15401,42 @@ const COMPLEX_GROUP_BY_EXCLUDED = /* @__PURE__ */ new Set([
 	"requestContext"
 ]);
 //#endregion
+//#region src/storage/db/sanitize-json.ts
+/**
+* Sanitizes JSON string for PostgreSQL jsonb:
+* - Removes problematic Unicode sequences:
+*   - \u0000 (null character) - causes error 22P05 "unsupported Unicode escape sequence"
+*   - \uD800-\uDFFF (unpaired surrogates) - causes "Unicode low surrogate must follow a high surrogate"
+*   - \\uD800 (escaped-backslash + surrogate, e.g. from JS regex literals like [^\ud800-\udfff]):
+*     removing just \uXXXX would leave a dangling backslash that creates a new invalid escape (e.g. \-)
+* - Escapes any remaining invalid JSON escape sequences (e.g. \v, \k, \-)
+*/
+function sanitizeJsonForPg(jsonString) {
+	return jsonString.replace(/\\\\?u(0000|[Dd][89A-Fa-f][0-9A-Fa-f]{2})/g, "").replace(/(^|[^\\])(\\(?!["\\/bfnrtu]))/g, "$1\\\\");
+}
+//#endregion
 //#region src/storage/domains/observability/v-next/sql.ts
 /**
 * SQL helpers for the v-next Postgres observability domain.
 *
-* Provides a multi-row INSERT builder with `ON CONFLICT DO NOTHING` for
-* insert-only retry idempotency, and explicit jsonb / text[] casts so the
-* pg driver doesn't have to guess column types.
+* Provides a multi-row INSERT builder with a configurable conflict clause
+* (`ON CONFLICT DO NOTHING` by default, for retry idempotency), and explicit
+* jsonb / text[] casts so the pg driver doesn't have to guess column types.
 */
 /**
 * Encode a JS value for a `$N::jsonb` cast. Always `JSON.stringify` so a
 * plain string like `"hello"` becomes `"hello"` (a valid JSON scalar) and
 * not the bare word `hello`, which Postgres rejects when cast to jsonb.
+*
+* The result is sanitized because Postgres rejects some sequences that are
+* legal in JSON: NUL (`\u0000`) fails with 22P05 and unpaired UTF-16
+* surrogates fail with 22P02. Inserts here are batched into a single
+* multi-row statement, so one bad value would otherwise reject the whole
+* batch of observability events.
 */
 function encodeJsonb(value) {
 	if (value === null || value === void 0) return null;
-	return JSON.stringify(value);
+	return sanitizeJsonForPg(JSON.stringify(value));
 }
 /**
 * Build a multi-row INSERT with explicit column types and ON CONFLICT DO NOTHING.
@@ -15262,7 +15447,7 @@ function encodeJsonb(value) {
 *                   All records must have identical key sets.
 * @returns          { text, values } ready to pass to `client.query`.
 */
-function buildInsert(schema, table, records) {
+function buildInsert(schema, table, records, onConflict = "ON CONFLICT DO NOTHING") {
 	if (records.length === 0) return null;
 	const columns = Object.keys(records[0]).map((c) => parseSqlIdentifier(c, "column name"));
 	const quotedColumns = columns.map((c) => `"${c}"`).join(", ");
@@ -15288,10 +15473,44 @@ function buildInsert(schema, table, records) {
 	return {
 		text: `INSERT INTO ${qualifiedTable(schema, table)} (${quotedColumns})
 VALUES ${rowPlaceholders.join(", ")}
-ON CONFLICT DO NOTHING`,
+${onConflict}`,
 		values
 	};
 }
+/** Primary key of the span table; also the conflict target for span upserts. */
+const SPAN_KEY_COLUMNS = [
+	"traceId",
+	"spanId",
+	"endedAt"
+];
+/**
+* Conflict clause for span writes.
+*
+* A span is written twice under the event-sourced strategy: once when it starts
+* (`isPending = true`, `endedAt` synthesized from `startedAt`) and once when it
+* ends. Those two rows normally differ in `endedAt` and so coexist under the
+* primary key. A zero-duration span is the exception — its real `endedAt`
+* equals its `startedAt`, so the end row collides with the pending row. Letting
+* `DO NOTHING` win there would strand the span as permanently running, so the
+* end row overwrites the pending one instead.
+*
+* The `WHERE` guard keeps the clause a no-op for every other conflict, which
+* preserves insert-only retry idempotency: a replayed end row cannot clobber
+* the row it duplicates, and a late-arriving start row cannot revert an ended
+* span to pending.
+*/
+function spanConflictClause(columns) {
+	return `ON CONFLICT ("traceId", "spanId", "endedAt") DO UPDATE SET ${columns.filter((column) => !SPAN_KEY_COLUMNS.includes(column)).map((column) => `"${column}" = EXCLUDED."${column}"`).join(", ")}
+WHERE ${TABLE_SPAN_EVENTS}."isPending" AND NOT EXCLUDED."isPending"`;
+}
+/**
+* Ordering that picks the winning row for a span under the event-sourced write
+* model. An ended row always beats a pending row for the same span; among rows
+* of the same kind the latest write wins, with `cursorId` breaking ties between
+* rows that share a timestamp. Combine with `DISTINCT ON` (or `LIMIT 1`) after
+* the grouping key to collapse a span's rows down to one.
+*/
+const SPAN_COLLAPSE_ORDER = "\"isPending\" ASC, \"endedAt\" DESC, \"cursorId\" DESC";
 /**
 * Standard SELECT column list for tracing tables. The select projects every
 * column the row→record converters expect.
@@ -16287,12 +16506,51 @@ async function getScorePercentiles(client, schema, args) {
 function asIsoTimestamp(value) {
 	return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
 }
+/**
+* Ordering that picks the row representing a trace's current root.
+*
+* A trace can hold more than one root row. A span is written once when it
+* starts and again when it ends, and a durable run that suspends ends its root
+* span and opens a fresh one on resume. In both cases the newest row is the one
+* that describes the trace right now, and `cursorId` — a sequence assigned at
+* insert — is what "newest" means here. It also orders correctly where
+* timestamps cannot: a zero-duration span has `startedAt = endedAt`, and a
+* resumed root starts after the suspended root ended.
+*/
+const ROOT_COLLAPSE_ORDER = "\"cursorId\" DESC";
+/**
+* Predicate that keeps only the winning row for each span — the ended row when
+* one exists, the newest row otherwise. Mirrors `SPAN_COLLAPSE_ORDER` as an
+* anti-join, for the same reason as {@link latestRootPredicate}.
+*/
+function latestSpanPredicate(spanTable) {
+	return `NOT EXISTS (
+    SELECT 1 FROM ${spanTable} newer
+    WHERE newer."traceId" = r."traceId"
+      AND newer."spanId" = r."spanId"
+      AND (newer."isPending" < r."isPending" OR (newer."isPending" = r."isPending" AND newer."cursorId" > r."cursorId"))
+  )`;
+}
+/**
+* Predicate that keeps only a trace's current root row, as an anti-join rather
+* than a `DISTINCT ON`. Written this way so the outer query still scans the
+* partial root indexes and streams rows in `LIMIT`-order; grouping first would
+* force every root in the table to be read before the first page came back.
+*/
+function latestRootPredicate(spanTable) {
+	return `NOT EXISTS (
+    SELECT 1 FROM ${spanTable} newer
+    WHERE newer."traceId" = r."traceId"
+      AND newer."parentSpanId" IS NULL
+      AND newer."cursorId" > r."cursorId"
+  )`;
+}
 async function getRootSpan(client, schema, args) {
 	const table = qualifiedTable(schema, TABLE_SPAN_EVENTS);
 	const row = await client.oneOrNone(`SELECT ${SPAN_SELECT_COLUMNS}
      FROM ${table}
      WHERE "traceId" = $1 AND "parentSpanId" IS NULL
-     ORDER BY "endedAt" DESC
+     ORDER BY ${ROOT_COLLAPSE_ORDER}
      LIMIT 1`, [args.traceId]);
 	if (!row) return null;
 	return { span: rowToSpanRecord(row) };
@@ -16304,7 +16562,7 @@ async function getRootSpan(client, schema, args) {
 * planner. Starts numbering from `nextParamIdx`.
 */
 function buildListTracesFilters(filters, spanTable, nextParamIdx) {
-	const conditions = [`r."parentSpanId" IS NULL`];
+	const conditions = [`r."parentSpanId" IS NULL`, latestRootPredicate(spanTable)];
 	const params = [];
 	let i = nextParamIdx;
 	if (!filters) return {
@@ -16321,11 +16579,11 @@ function buildListTracesFilters(filters, spanTable, nextParamIdx) {
 		params.push(asIsoTimestamp(filters.startedAt.end));
 	}
 	if (filters.endedAt?.start) {
-		conditions.push(`r."endedAt" ${filters.endedAt.startExclusive ? ">" : ">="} $${i++}`);
+		conditions.push(`(NOT r."isPending" AND r."endedAt" ${filters.endedAt.startExclusive ? ">" : ">="} $${i++})`);
 		params.push(asIsoTimestamp(filters.endedAt.start));
 	}
 	if (filters.endedAt?.end) {
-		conditions.push(`r."endedAt" ${filters.endedAt.endExclusive ? "<" : "<="} $${i++}`);
+		conditions.push(`(NOT r."isPending" AND r."endedAt" ${filters.endedAt.endExclusive ? "<" : "<="} $${i++})`);
 		params.push(asIsoTimestamp(filters.endedAt.end));
 	}
 	if (filters.spanType !== void 0) {
@@ -16397,10 +16655,10 @@ function buildListTracesFilters(filters, spanTable, nextParamIdx) {
 			conditions.push(`r."error" IS NOT NULL`);
 			break;
 		case TraceStatus.RUNNING:
-			conditions.push(`FALSE`);
+			conditions.push(`r."isPending"`);
 			break;
 		case TraceStatus.SUCCESS:
-			conditions.push(`r."error" IS NULL`);
+			conditions.push(`r."error" IS NULL AND NOT r."isPending"`);
 			break;
 	}
 	if (filters.hasChildError !== void 0) {
@@ -16537,8 +16795,8 @@ function buildBranchSpanTypeClause(userSpanType, params, startIdx) {
 * NOT have a `parentSpanId IS NULL` predicate — branches can be nested under
 * other spans. Returns the bound params and the next param index.
 */
-function buildListBranchesFilters(filters, spanType, nextParamIdx) {
-	const conditions = [];
+function buildListBranchesFilters(filters, spanType, spanTable, nextParamIdx) {
+	const conditions = [latestSpanPredicate(spanTable)];
 	const params = [];
 	let i = nextParamIdx;
 	const spanTypeClause = buildBranchSpanTypeClause(spanType, params, i);
@@ -16559,11 +16817,11 @@ function buildListBranchesFilters(filters, spanType, nextParamIdx) {
 		params.push(asIsoTimestamp(filters.startedAt.end));
 	}
 	if (filters.endedAt?.start) {
-		conditions.push(`r."endedAt" ${filters.endedAt.startExclusive ? ">" : ">="} $${i++}`);
+		conditions.push(`(NOT r."isPending" AND r."endedAt" ${filters.endedAt.startExclusive ? ">" : ">="} $${i++})`);
 		params.push(asIsoTimestamp(filters.endedAt.start));
 	}
 	if (filters.endedAt?.end) {
-		conditions.push(`r."endedAt" ${filters.endedAt.endExclusive ? "<" : "<="} $${i++}`);
+		conditions.push(`(NOT r."isPending" AND r."endedAt" ${filters.endedAt.endExclusive ? "<" : "<="} $${i++})`);
 		params.push(asIsoTimestamp(filters.endedAt.end));
 	}
 	if (filters.traceId !== void 0) {
@@ -16675,10 +16933,10 @@ function buildListBranchesFilters(filters, spanType, nextParamIdx) {
 			conditions.push(`r."error" IS NOT NULL`);
 			break;
 		case TraceStatus.RUNNING:
-			conditions.push(`FALSE`);
+			conditions.push(`r."isPending"`);
 			break;
 		case TraceStatus.SUCCESS:
-			conditions.push(`r."error" IS NULL`);
+			conditions.push(`r."error" IS NULL AND NOT r."isPending"`);
 			break;
 	}
 	return {
@@ -16697,7 +16955,7 @@ async function listBranches(client, schema, args) {
 	return listBranchesPage(client, span, filters, pagination.page, pagination.perPage, orderBy.field, orderBy.direction);
 }
 async function listBranchesPage(client, span, filters, page, perPage, orderField, orderDir) {
-	const built = buildListBranchesFilters(filters, filters?.spanType, 1);
+	const built = buildListBranchesFilters(filters, filters?.spanType, span, 1);
 	if (!built) {
 		const deltaCursor = deltaPollingFeatureEnabled() ? await readBranchesStreamHeadCursor(client, span, filters) : void 0;
 		return {
@@ -16751,7 +17009,7 @@ async function listBranchesDelta(client, span, filters, after, limit) {
 			deltaCursor
 		};
 	}
-	const built = buildListBranchesFilters(filters, filters?.spanType, 1);
+	const built = buildListBranchesFilters(filters, filters?.spanType, span, 1);
 	if (!built) return {
 		branches: [],
 		delta: {
@@ -16794,14 +17052,35 @@ async function readBranchesStreamHeadCursor(client, span, filters) {
 }
 //#endregion
 //#region src/storage/domains/observability/v-next/tracing.ts
-async function createSpan(client, schema, args) {
-	const insert = buildInsert(schema, TABLE_SPAN_EVENTS, [spanRecordToRow(args.span)]);
+async function writeSpanRows(client, schema, rows) {
+	const deduped = dedupeSpanRows(rows);
+	const insert = buildInsert(schema, TABLE_SPAN_EVENTS, deduped, spanConflictClause(Object.keys(deduped[0] ?? {})));
 	if (insert) await client.query(insert.text, insert.values);
 }
+/**
+* Collapse rows that share a primary key within a single batch. Postgres
+* rejects an `ON CONFLICT DO UPDATE` statement whose VALUES list would touch
+* the same row twice, which a batch containing both the start and the end of a
+* zero-duration span would do. The ended row wins, matching what the conflict
+* clause would have done across two separate statements.
+*/
+function dedupeSpanRows(rows) {
+	if (rows.length < 2) return rows;
+	const byKey = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const key = `${row.traceId}\u0000${row.spanId}\u0000${String(row.endedAt)}`;
+		const existing = byKey.get(key);
+		if (existing && !existing.isPending) continue;
+		byKey.set(key, row);
+	}
+	return [...byKey.values()];
+}
+async function createSpan(client, schema, args) {
+	await writeSpanRows(client, schema, [spanRecordToRow(args.span)]);
+}
 async function batchCreateSpans(client, schema, args) {
 	if (args.records.length === 0) return;
-	const insert = buildInsert(schema, TABLE_SPAN_EVENTS, args.records.map(spanRecordToRow));
-	if (insert) await client.query(insert.text, insert.values);
+	await writeSpanRows(client, schema, args.records.map(spanRecordToRow));
 }
 async function getSpans(client, schema, args) {
 	if (args.spanIds.length === 0) return {
@@ -16809,10 +17088,13 @@ async function getSpans(client, schema, args) {
 		spans: []
 	};
 	const table = qualifiedTable(schema, TABLE_SPAN_EVENTS);
-	const rows = await client.manyOrNone(`SELECT ${SPAN_SELECT_COLUMNS}
-     FROM ${table}
-     WHERE "traceId" = $1
-       AND "spanId" = ANY($2::text[])
+	const rows = await client.manyOrNone(`SELECT * FROM (
+       SELECT DISTINCT ON ("spanId") ${SPAN_SELECT_COLUMNS}
+       FROM ${table}
+       WHERE "traceId" = $1
+         AND "spanId" = ANY($2::text[])
+       ORDER BY "spanId", ${SPAN_COLLAPSE_ORDER}
+     ) collapsed
      ORDER BY "startedAt" ASC`, [args.traceId, args.spanIds]);
 	return {
 		traceId: args.traceId,
@@ -16824,16 +17106,19 @@ async function getSpan(client, schema, args) {
 	const row = await client.oneOrNone(`SELECT ${SPAN_SELECT_COLUMNS}
      FROM ${table}
      WHERE "traceId" = $1 AND "spanId" = $2
-     ORDER BY "endedAt" DESC
+     ORDER BY ${SPAN_COLLAPSE_ORDER}
      LIMIT 1`, [args.traceId, args.spanId]);
 	if (!row) return null;
 	return { span: rowToSpanRecord(row) };
 }
 async function getTrace(client, schema, args) {
 	const table = qualifiedTable(schema, TABLE_SPAN_EVENTS);
-	const rows = await client.manyOrNone(`SELECT ${SPAN_SELECT_COLUMNS}
-     FROM ${table}
-     WHERE "traceId" = $1
+	const rows = await client.manyOrNone(`SELECT * FROM (
+       SELECT DISTINCT ON ("spanId") ${SPAN_SELECT_COLUMNS}
+       FROM ${table}
+       WHERE "traceId" = $1
+       ORDER BY "spanId", ${SPAN_COLLAPSE_ORDER}
+     ) collapsed
      ORDER BY "startedAt" ASC`, [args.traceId]);
 	if (!rows.length) return null;
 	return {
@@ -16843,9 +17128,12 @@ async function getTrace(client, schema, args) {
 }
 async function getTraceLight(client, schema, args) {
 	const table = qualifiedTable(schema, TABLE_SPAN_EVENTS);
-	const rows = await client.manyOrNone(`SELECT ${SPAN_LIGHT_SELECT_COLUMNS}
-     FROM ${table}
-     WHERE "traceId" = $1
+	const rows = await client.manyOrNone(`SELECT * FROM (
+       SELECT DISTINCT ON ("spanId") ${SPAN_LIGHT_SELECT_COLUMNS}
+       FROM ${table}
+       WHERE "traceId" = $1
+       ORDER BY "spanId", ${SPAN_COLLAPSE_ORDER}
+     ) collapsed
      ORDER BY "startedAt" ASC`, [args.traceId]);
 	if (!rows.length) return null;
 	return {
@@ -16956,6 +17244,11 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 			} catch (error) {
 				if (!isDuplicateRelationError(error)) throw error;
 			}
+			for (const { table, column, ddl } of additiveColumns(this.#schema)) if (!await this.#client.oneOrNone(columnExistsSQL, [
+				this.#schema,
+				table,
+				column
+			])) await this.#client.none(ddl);
 			for (const ddl of allIndexDDL(this.#schema)) try {
 				await this.#client.none(ddl);
 			} catch (error) {
@@ -17052,8 +17345,8 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 	}
 	get observabilityStrategy() {
 		return {
-			preferred: "insert-only",
-			supported: ["insert-only"]
+			preferred: "event-sourced",
+			supported: ["event-sourced"]
 		};
 	}
 	getFeatures() {
@@ -20477,18 +20770,6 @@ function workflowSnapshotStatusIndexSQL(indexName, schemaName) {
 		schemaName: getSchemaName(schemaName)
 	})} (workflow_name, (snapshot ->> 'status'), "createdAt" DESC)`;
 }
-/**
-* Sanitizes JSON string for PostgreSQL jsonb:
-* - Removes problematic Unicode sequences:
-*   - \u0000 (null character) - causes error 22P05 "unsupported Unicode escape sequence"
-*   - \uD800-\uDFFF (unpaired surrogates) - causes "Unicode low surrogate must follow a high surrogate"
-*   - \\uD800 (escaped-backslash + surrogate, e.g. from JS regex literals like [^\ud800-\udfff]):
-*     removing just \uXXXX would leave a dangling backslash that creates a new invalid escape (e.g. \-)
-* - Escapes any remaining invalid JSON escape sequences (e.g. \v, \k, \-)
-*/
-function sanitizeJsonForPg(jsonString) {
-	return jsonString.replace(/\\\\?u(0000|[Dd][89A-Fa-f][0-9A-Fa-f]{2})/g, "").replace(/(^|[^\\])(\\(?!["\\/bfnrtu]))/g, "$1\\\\");
-}
 var WorkflowsPG = class WorkflowsPG extends WorkflowsStorage {
 	#db;
 	#schema;
@@ -20768,11 +21049,11 @@ var WorkflowsPG = class WorkflowsPG extends WorkflowsStorage {
 			await this.#db.client.none(`INSERT INTO ${getTableName({
 				indexName: TABLE_WORKFLOW_SNAPSHOT,
 				schemaName: getSchemaName(this.#schema)
-			})}
+			})} AS t
                  (workflow_name, run_id, "resourceId", snapshot, "createdAt", "updatedAt", "createdAtZ", "updatedAtZ")
                  VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
                  ON CONFLICT (workflow_name, run_id) DO UPDATE
-                 SET "resourceId" = $3, snapshot = $4, "updatedAt" = $6, "updatedAtZ" = $8`, [
+                 SET "resourceId" = COALESCE($3, t."resourceId"), snapshot = $4, "updatedAt" = $6, "updatedAtZ" = $8`, [
 				workflowName,
 				runId,
 				resourceId,
@@ -21730,6 +22011,12 @@ var PgFactoryStorageOps = class {
 	async findMany(collection, where, opts) {
 		return this.#select(this.#queryable, collection, where, opts);
 	}
+	async count(collection, where) {
+		const schema = this.#schema(collection);
+		const filter = this.#buildWhere(schema, where);
+		const result = await this.#queryable.query(`SELECT COUNT(*) AS count FROM "${schema.name}" WHERE ${filter.sql}`, filter.args);
+		return Number(result.rows[0]?.count ?? 0);
+	}
 	async insertOne(collection, row) {
 		const schema = this.#schema(collection);
 		const pk = primaryKeyOf(schema);