emdash 0.36.0 → 0.38.0

package/dist/{context-BR5hRWiK.mjs → context-C9PB8vGd.mjs}

@@ -1,18 +1,20 @@
-import { d as pluginDataExtractExpr, f as pluginDataOrderExpr } from "./dialect-helpers-BSbfaO3F.mjs";
+import { n as validateJsonFieldName } from "./validate-BpwoDOgt.mjs";
+import { f as pluginDataExtractExpr, h as pluginDataWriteExpr, m as pluginDataUpdateGuard, p as pluginDataOrderExpr } from "./dialect-helpers-BcQvkHgn.mjs";
 import { o as resolveContentCreateLocale } from "./config-C3EBstHi.mjs";
-import { t as ContentRepository } from "./content-CP-SeXNa.mjs";
+import { t as ContentRepository } from "./content-CNfMWuhY.mjs";
 import { o as decodeCursor, s as encodeCursor } from "./types-CQPWhPxE.mjs";
-import { t as MediaRepository } from "./media-D6SeAfBl.mjs";
-import { t as UserRepository } from "./user-CtYY0tp2.mjs";
+import { t as MediaRepository } from "./media-BBm8Wg3f.mjs";
+import { t as UserRepository } from "./user-DIsIXogT.mjs";
 import { t as withTransaction } from "./transaction-0KOpOyMu.mjs";
-import { t as TaxonomyRepository } from "./taxonomy-8X09dLN5.mjs";
-import { t as OptionsRepository } from "./options-BHPeIbBd.mjs";
-import { t as enrichImageMetadata } from "./enrich-BX0IDp4z.mjs";
-import { t as SeoRepository } from "./seo-Cm-dtvgk.mjs";
-import { l as markContentMediaUsageCollectionStaleSafely } from "./content-refresh-DLOfIhYc.mjs";
-import { o as invalidateSiteSettingsCache } from "./settings-BgN-0DT-.mjs";
-import { a as stripCredentialHeaders, n as resolveAndValidateExternalUrl, t as SsrfError } from "./ssrf-DqebVE34.mjs";
-import { t as CronAccessImpl } from "./cron-CWfWrWKG.mjs";
+import { t as TaxonomyRepository } from "./taxonomy-DP1vny4K.mjs";
+import { i as serializeConditionalValue, n as assertStorageKey, r as assertStorageRevision, t as OptionsRepository } from "./options-D1FBiAv1.mjs";
+import { t as enrichImageMetadata } from "./enrich-t2Xvjdqa.mjs";
+import { t as EntryLockRepository } from "./entry-locks-BEcX7ET0.mjs";
+import { t as SeoRepository } from "./seo-Bw68KxRc.mjs";
+import { l as markContentMediaUsageCollectionStaleSafely } from "./content-refresh-GTMyi2Xy.mjs";
+import { s as invalidateSiteSettingsCache } from "./settings-DcMjREe5.mjs";
+import { o as stripCredentialHeaders, r as resolveAndValidateExternalUrl, t as SsrfError } from "./ssrf-gl4gFNhw.mjs";
+import { t as CronAccessImpl } from "./cron-DHAy9oyq.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
@@ -29,6 +31,36 @@ var StorageQueryError = class extends Error {
 	}
 };
 /**
+* Error thrown when a guarded `updateIf` loses a concurrent race by aborting
+* rather than resolving to `{ applied: false }`.
+*
+* `updateIf`'s `{ applied: false }` contract (row absent OR guard failed)
+* assumes READ COMMITTED — the default. There, a losing concurrent writer
+* re-evaluates the guard against the winner's freshly committed row and
+* cleanly resolves to `{ applied: false }`. Two aborts escape that contract:
+*
+* - `40001` (serialization_failure), only above READ COMMITTED, where the
+*   loser cannot re-read against a newer snapshot.
+* - `40P01` (deadlock_detected), at any isolation level, when transactions
+*   take row locks in opposite order.
+*
+* This error surfaces either abort so the caller can retry the write.
+*
+* The no-oversell SAFETY invariant holds either way: a losing writer NEVER
+* applies its update — it either sees `{ applied: false }` or throws here.
+*/
+var StorageSerializationError = class extends Error {
+	code = "STORAGE_SERIALIZATION_FAILURE";
+	retryable = true;
+	/** The Postgres SQLSTATE that triggered this error (`40001` / `40P01`). */
+	sqlState;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.name = "StorageSerializationError";
+		this.sqlState = options?.sqlState;
+	}
+};
+/**
 * Check if a value is a range filter
 */
 function isRangeFilter(value) {
@@ -145,6 +177,7 @@ function buildCondition(db, field, value) {
 		if (value.gte !== void 0) pushBound(">=", value.gte);
 		if (value.lt !== void 0) pushBound("<", value.lt);
 		if (value.lte !== void 0) pushBound("<=", value.lte);
+		if (conditions.length === 0) throw new StorageQueryError(`Range filter for field '${field}' has no defined bound`, field, "Provide at least one of gt, gte, lt, or lte, or omit the field.");
 		return {
 			sql: conditions.join(" AND "),
 			params
@@ -160,6 +193,7 @@ function buildWhereClause(db, where) {
 	const params = [];
 	for (const [field, value] of Object.entries(where)) {
 		const condition = buildCondition(db, field, value);
+		if (!condition.sql) continue;
 		conditions.push(condition.sql);
 		params.push(...condition.params);
 	}
@@ -173,9 +207,113 @@ function buildWhereClause(db, where) {
 	};
 }
 
+//#endregion
+//#region src/plugins/storage-update.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireRecord(value, label) {
+	if (!isRecord(value)) throw new TypeError(`${label} must be an object`);
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new TypeError(`${label} must be a plain object`);
+	return value;
+}
+function operand(value) {
+	if (typeof value === "string" || typeof value === "number" && Number.isFinite(value)) return value;
+	throw new TypeError("Storage guard operands must be strings or finite numbers");
+}
+function normalizeFilter(value) {
+	if (value === null || typeof value === "boolean") return value;
+	if (typeof value === "string" || typeof value === "number") return operand(value);
+	const filter = requireRecord(value, "Storage guard filter");
+	const values = filter.in;
+	if (Array.isArray(values)) return { in: Array.from(values, operand) };
+	const prefix = filter.startsWith;
+	if (typeof prefix === "string") return { startsWith: prefix };
+	const range = {};
+	for (const key of [
+		"gt",
+		"gte",
+		"lt",
+		"lte"
+	]) if (key in filter) {
+		const bound = filter[key];
+		range[key] = bound === void 0 ? void 0 : operand(bound);
+	}
+	return range;
+}
+function parseStorageUpdate(value) {
+	const args = requireRecord(value, "Storage update arguments");
+	if (Object.keys(args).some((key) => key !== "where" && key !== "set" && key !== "delta")) throw new TypeError("Unknown storage update argument");
+	const where = {};
+	for (const [field, filter] of Object.entries(requireRecord(args.where, "Storage where guard"))) {
+		validateJsonFieldName(field);
+		where[field] = normalizeFilter(filter);
+	}
+	const set = args.set === void 0 ? {} : requireRecord(args.set, "Storage set");
+	const delta = args.delta === void 0 ? {} : requireRecord(args.delta, "Storage delta");
+	const setEntries = [];
+	for (const [field, entry] of Object.entries(set)) {
+		if (entry === void 0) continue;
+		validateJsonFieldName(field);
+		const serialized = JSON.stringify(entry);
+		if (serialized === void 0) throw new TypeError("Storage set values must be JSON serializable");
+		const normalized = JSON.parse(serialized);
+		setEntries.push([field, normalized]);
+	}
+	const setFields = new Set(setEntries.map(([field]) => field));
+	const deltaEntries = [];
+	for (const [field, entry] of Object.entries(delta)) {
+		if (entry === void 0) continue;
+		validateJsonFieldName(field);
+		if (setFields.has(field)) throw new TypeError("Storage field appears in both set and delta");
+		const spec = requireRecord(entry, "Storage numeric delta");
+		const keys = Object.keys(spec);
+		const key = keys[0];
+		if (keys.length !== 1 || key !== "inc" && key !== "dec") throw new TypeError("Storage delta must contain exactly one of inc or dec");
+		const amount = spec[key];
+		if (typeof amount !== "number" || !Number.isSafeInteger(amount)) throw new TypeError("Storage delta must be a safe integer");
+		deltaEntries.push([field, key === "dec" ? -amount : amount]);
+	}
+	if (setEntries.length + deltaEntries.length === 0) throw new TypeError("Storage update requires at least one of set or delta");
+	return {
+		where,
+		setEntries,
+		deltaEntries
+	};
+}
+
 //#endregion
 //#region src/database/repositories/plugin-storage.ts
 /**
+* SQLSTATEs a losing concurrent `updateIf` writer can abort with.
+*
+* `40001` (serialization_failure) is raised only above READ COMMITTED, where
+* the loser cannot re-evaluate its guard against a newer snapshot. `40P01`
+* (deadlock_detected) is not tied to isolation level: it needs only two
+* transactions taking row locks in opposite order, which a caller reaches at
+* READ COMMITTED by wrapping several `updateIf` calls in one transaction.
+*/
+const SERIALIZATION_SQLSTATES = new Set(["40001", "40P01"]);
+function errSqlState(err) {
+	if (typeof err !== "object" || err === null) return void 0;
+	const code = err.code;
+	if (typeof code === "string") return code;
+	const cause = err.cause;
+	if (typeof cause === "object" && cause !== null) {
+		const causeCode = cause.code;
+		if (typeof causeCode === "string") return causeCode;
+	}
+}
+function mapSerializationFailure(err) {
+	const sqlState = errSqlState(err);
+	if (sqlState !== void 0 && SERIALIZATION_SQLSTATES.has(sqlState)) return new StorageSerializationError("Storage write must be retried. Restart the transaction before retrying when using an explicit transaction.", {
+		cause: err,
+		sqlState
+	});
+	return err;
+}
+/**
 * Interleave a `?`-placeholder SQL string with its params into a single
 * boolean raw expression. Used as a WHERE predicate directly — wrapping it
 * in `(...) = 1` breaks on Postgres, which has a strict boolean type (#920).
@@ -195,6 +333,18 @@ function rawWhereExpr(sqlText, params) {
 *
 * Implements the StorageCollection interface for a specific plugin and collection.
 */
+/**
+* Rank a sort expression so NULLs get a deterministic position.
+*
+* A missing key in a schemaless document extracts as NULL, which sorts
+* differently per dialect (SQLite first, Postgres last) and makes every
+* comparison against it UNKNOWN. Sorting on this rank ahead of the value puts
+* NULLs in the same place on both dialects and keeps the seek operands
+* non-NULL.
+*/
+function nullRank(expr) {
+	return sql`(case when ${expr} is null then 1 else 0 end)`;
+}
 var PluginStorageRepository = class {
 	indexedFields;
 	constructor(db, pluginId, collection, indexes) {
@@ -217,11 +367,13 @@ var PluginStorageRepository = class {
 	async put(id, data) {
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const jsonData = JSON.stringify(data);
+		const revision = crypto.randomUUID();
 		await this.db.insertInto("_plugin_storage").values({
 			plugin_id: this.pluginId,
 			collection: this.collection,
 			id,
 			data: jsonData,
+			revision,
 			created_at: now,
 			updated_at: now
 		}).onConflict((oc) => oc.columns([
@@ -230,9 +382,52 @@ var PluginStorageRepository = class {
 			"id"
 		]).doUpdateSet({
 			data: jsonData,
+			revision,
 			updated_at: now
 		})).execute();
 	}
+	async getVersioned(id) {
+		assertStorageKey(id);
+		const row = await this.db.selectFrom("_plugin_storage").select(["data", "revision"]).where("plugin_id", "=", this.pluginId).where("collection", "=", this.collection).where("id", "=", id).executeTakeFirst();
+		if (!row) return null;
+		return {
+			value: JSON.parse(row.data),
+			revision: row.revision
+		};
+	}
+	async compareAndSet(id, expectedRevision, data) {
+		assertStorageKey(id);
+		if (expectedRevision !== null) assertStorageRevision(expectedRevision);
+		const jsonData = serializeConditionalValue(data);
+		const revision = crypto.randomUUID();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const row = expectedRevision === null ? await this.db.insertInto("_plugin_storage").values({
+			plugin_id: this.pluginId,
+			collection: this.collection,
+			id,
+			data: jsonData,
+			revision,
+			created_at: now,
+			updated_at: now
+		}).onConflict((oc) => oc.columns([
+			"plugin_id",
+			"collection",
+			"id"
+		]).doNothing()).returning("revision").executeTakeFirst() : await this.db.updateTable("_plugin_storage").set({
+			data: jsonData,
+			revision,
+			updated_at: now
+		}).where("plugin_id", "=", this.pluginId).where("collection", "=", this.collection).where("id", "=", id).where("revision", "=", expectedRevision).returning("revision").executeTakeFirst();
+		return row ? {
+			applied: true,
+			revision: row.revision
+		} : { applied: false };
+	}
+	async compareAndDelete(id, expectedRevision) {
+		assertStorageKey(id);
+		assertStorageRevision(expectedRevision);
+		return { applied: await this.db.deleteFrom("_plugin_storage").where("plugin_id", "=", this.pluginId).where("collection", "=", this.collection).where("id", "=", id).where("revision", "=", expectedRevision).returning("id").executeTakeFirst() !== void 0 };
+	}
 	/**
 	* Delete a document
 	*/
@@ -264,11 +459,13 @@ var PluginStorageRepository = class {
 		await withTransaction(this.db, async (trx) => {
 			for (const item of items) {
 				const jsonData = JSON.stringify(item.data);
+				const revision = crypto.randomUUID();
 				await trx.insertInto("_plugin_storage").values({
 					plugin_id: this.pluginId,
 					collection: this.collection,
 					id: item.id,
 					data: jsonData,
+					revision,
 					created_at: now,
 					updated_at: now
 				}).onConflict((oc) => oc.columns([
@@ -277,6 +474,7 @@ var PluginStorageRepository = class {
 					"id"
 				]).doUpdateSet({
 					data: jsonData,
+					revision,
 					updated_at: now
 				})).execute();
 			}
@@ -305,16 +503,39 @@ var PluginStorageRepository = class {
 		]).where("plugin_id", "=", this.pluginId).where("collection", "=", this.collection);
 		const whereResult = buildWhereClause(this.db, where);
 		if (whereResult.sql) query = query.where(rawWhereExpr(whereResult.sql, whereResult.params));
+		const orderEntries = Object.entries(orderBy);
+		const orderDirections = new Set(orderEntries.map(([, direction]) => direction));
+		const descending = orderEntries.length > 0 && orderEntries[0][1] === "desc";
+		const sortExpr = (field) => sql`${sql.raw(jsonOrderExtract(this.db, field))}`;
 		if (cursor) {
 			const decoded = decodeCursor(cursor);
-			query = query.where(({ eb }) => eb(sql`(created_at, id)`, ">", sql`(${decoded.orderValue}, ${decoded.id})`));
-		}
-		if (Object.keys(orderBy).length > 0) for (const [field, direction] of Object.entries(orderBy)) {
-			const extract = jsonOrderExtract(this.db, field);
-			const orderExpr = direction === "desc" ? sql`${sql.raw(extract)} desc` : sql`${sql.raw(extract)} asc`;
-			query = query.orderBy(orderExpr);
+			if (orderEntries.length === 0) query = query.where(({ eb }) => eb(sql`(created_at, id)`, ">", sql`(${decoded.orderValue}, ${decoded.id})`));
+			else {
+				if (orderDirections.size > 1) throw new StorageQueryError("Cursor pagination requires every orderBy field to share one direction.", Object.keys(orderBy).join(", "), "Sort every field the same way, or page without a cursor.");
+				const op = descending ? sql`<` : sql`>`;
+				const cursorExpr = (field) => sql`(select ${sql.raw(jsonOrderExtract(this.db, field))} from _plugin_storage where plugin_id = ${this.pluginId} and collection = ${this.collection} and id = ${decoded.id})`;
+				const fields = orderEntries.map(([field]) => {
+					const own = sortExpr(field);
+					const theirs = cursorExpr(field);
+					return {
+						equal: sql`(${nullRank(own)} = ${nullRank(theirs)} and (${nullRank(own)} = 1 or ${own} = ${theirs}))`,
+						after: sql`(${nullRank(own)} ${op} ${nullRank(theirs)} or (${nullRank(own)} = ${nullRank(theirs)} and ${nullRank(own)} = 0 and ${own} ${op} ${theirs}))`
+					};
+				});
+				const terms = fields.map((_, k) => sql`(${sql.join([...fields.slice(0, k).map((f) => f.equal), fields[k].after], sql` and `)})`);
+				terms.push(sql`(${sql.join([...fields.map((f) => f.equal), sql`id ${op} ${decoded.id}`], sql` and `)})`);
+				query = query.where(sql`(${sql.join(terms, sql` or `)})`);
+			}
 		}
-		else query = query.orderBy("created_at", "asc").orderBy("id", "asc");
+		if (orderEntries.length > 0) {
+			for (const [field, direction] of orderEntries) {
+				const dir = direction === "desc" ? sql`desc` : sql`asc`;
+				const expr = sortExpr(field);
+				query = query.orderBy(sql`${nullRank(expr)} ${dir}`);
+				query = query.orderBy(sql`${expr} ${dir}`);
+			}
+			query = query.orderBy("id", descending ? "desc" : "asc");
+		} else query = query.orderBy("created_at", "asc").orderBy("id", "asc");
 		query = query.limit(limit + 1);
 		const rows = await query.execute();
 		const hasMore = rows.length > limit;
@@ -346,6 +567,30 @@ var PluginStorageRepository = class {
 		const result = await query.executeTakeFirst();
 		return Number(result?.count ?? 0);
 	}
+	async updateIf(id, args) {
+		if (typeof id !== "string") throw new TypeError("Storage ID must be a string");
+		const { where, setEntries, deltaEntries } = parseStorageUpdate(args);
+		for (const value of Object.values(where)) if (isInFilter(value) && value.in.length === 0) return { applied: false };
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const dataExpr = pluginDataWriteExpr(this.db, setEntries, deltaEntries);
+		let query = this.db.updateTable("_plugin_storage").set({
+			data: dataExpr,
+			updated_at: now
+		}).where("plugin_id", "=", this.pluginId).where("collection", "=", this.collection).where("id", "=", id).where(pluginDataUpdateGuard(this.db, deltaEntries));
+		const whereResult = buildWhereClause(this.db, where);
+		if (whereResult.sql) query = query.where(rawWhereExpr(whereResult.sql, whereResult.params));
+		let row;
+		try {
+			row = await query.returning("data").executeTakeFirst();
+		} catch (err) {
+			throw mapSerializationFailure(err);
+		}
+		if (!row) return { applied: false };
+		return {
+			applied: true,
+			data: JSON.parse(row.data)
+		};
+	}
 };
 
 //#endregion
@@ -360,6 +605,18 @@ function createKVAccess(optionsRepo, pluginId) {
 		async get(key) {
 			return optionsRepo.get(`${prefix}${key}`);
 		},
+		async getVersioned(key) {
+			assertStorageKey(key);
+			return optionsRepo.getVersioned(`${prefix}${key}`);
+		},
+		async compareAndSet(key, expectedRevision, value) {
+			assertStorageKey(key);
+			return optionsRepo.compareAndSet(`${prefix}${key}`, expectedRevision, value);
+		},
+		async compareAndDelete(key, expectedRevision) {
+			assertStorageKey(key);
+			return optionsRepo.compareAndDelete(`${prefix}${key}`, expectedRevision);
+		},
 		async set(key, value) {
 			await optionsRepo.set(`${prefix}${key}`, value);
 		},
@@ -386,6 +643,9 @@ function createStorageCollection(db, pluginId, collectionName, indexes) {
 	const repo = new PluginStorageRepository(db, pluginId, collectionName, indexes);
 	return {
 		get: (id) => repo.get(id),
+		getVersioned: (id) => repo.getVersioned(id),
+		compareAndSet: (id, expectedRevision, data) => repo.compareAndSet(id, expectedRevision, data),
+		compareAndDelete: (id, expectedRevision) => repo.compareAndDelete(id, expectedRevision),
 		put: (id, data) => repo.put(id, data),
 		delete: (id) => repo.delete(id),
 		exists: (id) => repo.exists(id),
@@ -393,6 +653,7 @@ function createStorageCollection(db, pluginId, collectionName, indexes) {
 		putMany: (items) => repo.putMany(items),
 		deleteMany: (ids) => repo.deleteMany(ids),
 		count: (where) => repo.count(where),
+		updateIf: (id, updateArgs) => repo.updateIf(id, updateArgs),
 		async query(options) {
 			const result = await repo.query({
 				where: options?.where,
@@ -648,7 +909,10 @@ function createContentAccessWithWrite(db, beforeContentWrite) {
 		async delete(collection, id) {
 			await beforeContentWrite?.();
 			const deleted = await new ContentRepository(db).delete(collection, id);
-			if (deleted) await markContentMediaUsageCollectionStaleSafely(db, collection, "CONTENT_USAGE_STALE");
+			if (deleted) {
+				await new EntryLockRepository(db).releaseEntry(collection, id);
+				await markContentMediaUsageCollectionStaleSafely(db, collection, "CONTENT_USAGE_STALE");
+			}
 			return deleted;
 		}
 	};
@@ -787,11 +1051,26 @@ function isHostAllowed(host, allowedHosts) {
 		return host === pattern;
 	});
 }
+function tryParsePluginHttpTarget(url) {
+	try {
+		return new URL(url);
+	} catch {
+		return null;
+	}
+}
+async function validatePluginHttpTarget(pluginId, url) {
+	try {
+		return await resolveAndValidateExternalUrl(url);
+	} catch (error) {
+		const message = error instanceof SsrfError ? error.message : "SSRF validation failed";
+		const target = tryParsePluginHttpTarget(url);
+		throw new Error(`Plugin "${pluginId}": blocked fetch to "${target ? target.hostname : "invalid URL"}": ${message}`, { cause: error });
+	}
+}
 /**
-* Create HTTP access with host validation.
+* Create HTTP access with host validation and SSRF protection.
 *
-* Uses redirect: "manual" to re-validate each redirect target against
-* the allowedHosts list, preventing redirects to unauthorized hosts.
+* Uses redirect: "manual" to re-validate each redirect target before dispatch.
 */
 function createHttpAccess(pluginId, allowedHosts) {
 	return { async fetch(url, init) {
@@ -799,8 +1078,9 @@ function createHttpAccess(pluginId, allowedHosts) {
 		let currentUrl = url;
 		let currentInit = init;
 		for (let i = 0; i <= MAX_PLUGIN_REDIRECTS; i++) {
-			const hostname = new URL(currentUrl).hostname;
-			if (!isHostAllowed(hostname, allowedHosts)) throw new Error(`Plugin "${pluginId}" is not allowed to fetch from host "${hostname}". Allowed hosts: ${allowedHosts.join(", ")}`);
+			const target = tryParsePluginHttpTarget(currentUrl);
+			if (target && !isHostAllowed(target.hostname, allowedHosts)) throw new Error(`Plugin "${pluginId}" is not allowed to fetch from host "${target.hostname}". Allowed hosts: ${allowedHosts.join(", ")}`);
+			await validatePluginHttpTarget(pluginId, currentUrl);
 			const response = await globalThis.fetch(currentUrl, {
 				...currentInit,
 				redirect: "manual"
@@ -825,12 +1105,7 @@ function createUnrestrictedHttpAccess(pluginId) {
 		let currentUrl = url;
 		let currentInit = init;
 		for (let i = 0; i <= MAX_PLUGIN_REDIRECTS; i++) {
-			try {
-				await resolveAndValidateExternalUrl(currentUrl);
-			} catch (e) {
-				const msg = e instanceof SsrfError ? e.message : "SSRF validation failed";
-				throw new Error(`Plugin "${pluginId}": blocked fetch to "${new URL(currentUrl).hostname}": ${msg}`, { cause: e });
-			}
+			await validatePluginHttpTarget(pluginId, currentUrl);
 			const response = await globalThis.fetch(currentUrl, {
 				...currentInit,
 				redirect: "manual"
@@ -1029,5 +1304,5 @@ var PluginContextFactory = class {
 };
 
 //#endregion
-export { createUnrestrictedHttpAccess as a, createStorageAccess as i, createHttpAccess as n, PluginStorageRepository as o, createSiteInfo as r, PluginContextFactory as t };
-//# sourceMappingURL=context-BR5hRWiK.mjs.map
+export { createUnrestrictedHttpAccess as a, createStorageAccess as i, createHttpAccess as n, PluginStorageRepository as o, createSiteInfo as r, StorageSerializationError as s, PluginContextFactory as t };
+//# sourceMappingURL=context-C9PB8vGd.mjs.map