@agentmemory/agentmemory 0.9.29 → 0.9.31

package/dist/{standalone-BqNJDJ04.mjs → standalone-BlqshyZ5.mjs}

@@ -1,5 +1,6 @@
-import { i as generateId } from "./schema-BFZhNTF7.mjs";
-import { f as getStandalonePersistPath, i as VERSION, n as getAllTools } from "./tools-registry-BV_2bu7z.mjs";
+import { s as generateId } from "./keyed-mutex-DCUh7PG-.mjs";
+import { R as getAgentId, Y as getStandalonePersistPath, c as memoryToObservation, i as resolveClientSecret, m as queryAudit, o as buildRecallResponse, tt as isAgentScopeIsolated, u as isSearchLayer, w as VERSION, x as getAllTools } from "./secret-store-D9GwO0xp.mjs";
+import { a as pageAfterCursor, c as sortByKeyDesc, n as parseSearchExpansionIds, t as parseSessionArguments } from "./session-arguments-zxsbbd8y.mjs";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 //#region src/mcp/in-memory-kv.ts
@@ -32,20 +33,30 @@ var InMemoryKV = class {
 		return entries ? Array.from(entries.values()) : [];
 	}
 	persist() {
-		if (!this.persistPath) return;
+		if (!this.persistPath) return false;
 		try {
 			const dir = dirname(this.persistPath);
 			if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 			const data = {};
 			for (const [scope, entries] of this.store) data[scope] = Object.fromEntries(entries);
 			writeFileSync(this.persistPath, JSON.stringify(data), "utf-8");
+			return true;
 		} catch (err) {
 			process.stderr.write(`[@agentmemory/mcp] Persist failed: ${err instanceof Error ? err.message : String(err)}\n`);
+			return false;
 		}
 	}
 };
 //#endregion
 //#region src/mcp/transport.ts
+let activeStdioTransports = 0;
+var JsonRpcError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "JsonRpcError";
+	}
+};
 function isNotification(req) {
 	return req.id === void 0 || req.id === null;
 }
@@ -111,7 +122,7 @@ async function processLine(line, handler, writeOut, writeErr = (msg) => process.
 			jsonrpc: "2.0",
 			id: request.id,
 			error: {
-				code: -32603,
+				code: err instanceof JsonRpcError ? err.code : -32603,
 				message: err instanceof Error ? err.message : String(err)
 			}
 		});
@@ -191,6 +202,7 @@ function createMessageParser(onMessage, writeErr = (msg) => process.stderr.write
 function createStdioTransport(handler) {
 	let parser = null;
 	let queue = Promise.resolve();
+	let active = false;
 	const writeResponse = (response) => {
 		const formatted = formatResponse(response, parser?.isFramed() ?? false);
 		if (typeof formatted === "string") {
@@ -202,6 +214,10 @@ function createStdioTransport(handler) {
 	const onData = (chunk) => parser?.push(chunk);
 	return {
 		start() {
+			if (active) return;
+			active = true;
+			activeStdioTransports += 1;
+			process.env["AGENTMEMORY_MCP_STDIO__"] = "1";
 			parser = createMessageParser((message) => {
 				queue = queue.then(() => processLine(message, handler, writeResponse));
 				queue.catch((err) => {
@@ -212,6 +228,11 @@ function createStdioTransport(handler) {
 		},
 		stop() {
 			process.stdin.off("data", onData);
+			if (active) {
+				active = false;
+				activeStdioTransports -= 1;
+				if (activeStdioTransports === 0) delete process.env["AGENTMEMORY_MCP_STDIO__"];
+			}
 			parser = null;
 		}
 	};
@@ -228,11 +249,22 @@ function probeTimeoutMs() {
 	const n = Number(raw);
 	return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_HEALTH_PROBE_TIMEOUT_MS;
 }
-function forceProxy() {
+function isProxyRequired() {
 	const raw = process.env["AGENTMEMORY_FORCE_PROXY"];
 	return raw === "1" || raw === "true";
 }
+var ProxyCallError = class extends Error {
+	status;
+	body;
+	constructor(message, status, body) {
+		super(message);
+		this.name = "ProxyCallError";
+		this.status = status;
+		this.body = body;
+	}
+};
 let cached = null;
+let cachedUrl = null;
 let cachedAt = 0;
 let probeInFlight = null;
 function resolveEnvOrEmpty(name) {
@@ -242,17 +274,25 @@ function resolveEnvOrEmpty(name) {
 	return raw;
 }
 function baseUrl() {
-	return (resolveEnvOrEmpty("AGENTMEMORY_URL") || DEFAULT_URL).replace(/\/+$/, "");
+	const value = resolveEnvOrEmpty("AGENTMEMORY_URL") || DEFAULT_URL;
+	try {
+		const parsed = new URL(value);
+		if (!["http:", "https:"].includes(parsed.protocol) || !parsed.hostname || parsed.username || parsed.password || /[?#\s]/.test(value)) throw new Error();
+		return value.replace(/\/+$/, "");
+	} catch {
+		throw new Error("AGENTMEMORY_URL must be an HTTP(S) URL without credentials, query, or fragment");
+	}
 }
-function authHeader() {
-	const secret = resolveEnvOrEmpty("AGENTMEMORY_SECRET");
+function authHeader(url) {
+	const secret = resolveClientSecret(url);
 	return secret ? { authorization: `Bearer ${secret}` } : {};
 }
 const defaultLivezProbe = async (url, timeoutMs, headers) => {
 	const res = await fetch(`${url}/agentmemory/livez`, {
 		method: "GET",
 		headers,
-		signal: AbortSignal.timeout(timeoutMs)
+		signal: AbortSignal.timeout(timeoutMs),
+		redirect: "error"
 	});
 	return {
 		ok: res.ok,
@@ -264,7 +304,7 @@ let livezProbe = defaultLivezProbe;
 async function probe(url) {
 	const timeout = probeTimeoutMs();
 	try {
-		const res = await livezProbe(url, timeout, authHeader());
+		const res = await livezProbe(url, timeout, authHeader(url));
 		if (!res.ok) process.stderr.write(`[@agentmemory/mcp] livez probe ${url}/agentmemory/livez -> ${res.status ?? "?"} ${res.statusText ?? ""}; falling back to local InMemoryKV (set AGENTMEMORY_FORCE_PROXY=1 to skip the probe)\n`);
 		return res.ok;
 	} catch (err) {
@@ -274,52 +314,73 @@ async function probe(url) {
 }
 function invalidateHandle() {
 	cached = null;
+	cachedUrl = null;
 	cachedAt = 0;
 }
 async function resolveHandle() {
 	const now = Date.now();
+	const url = baseUrl();
+	if (cached && (cachedUrl !== url || cached.mode === "local" && isProxyRequired())) invalidateHandle();
 	if (cached) if (cached.mode === "local" && now - cachedAt >= LOCAL_MODE_TTL_MS) {
 		cached = null;
 		cachedAt = 0;
 	} else return cached;
-	if (probeInFlight) return probeInFlight;
-	const url = baseUrl();
-	const skipProbe = forceProxy();
-	probeInFlight = (async () => {
+	const skipProbe = isProxyRequired();
+	if (probeInFlight?.url === url && probeInFlight.forceProxy === skipProbe) return probeInFlight.promise;
+	const pending = (async () => {
 		const up = skipProbe ? true : await probe(url);
+		if (baseUrl() !== url || isProxyRequired() !== skipProbe) return resolveHandle();
 		if (skipProbe) process.stderr.write(`[@agentmemory/mcp] AGENTMEMORY_FORCE_PROXY set; skipping livez probe and trusting ${url}\n`);
 		if (up) {
 			const handle = {
 				mode: "proxy",
 				baseUrl: url,
 				call: async (path, init) => {
+					if (baseUrl() !== url) throw new Error("AgentMemory endpoint changed; resolve a new proxy handle before retrying.");
 					const res = await fetch(`${url}${path}`, {
 						...init,
 						headers: {
 							"content-type": "application/json",
-							...authHeader(),
+							...authHeader(url),
 							...init?.headers
 						},
-						signal: AbortSignal.timeout(CALL_TIMEOUT_MS)
+						signal: AbortSignal.timeout(CALL_TIMEOUT_MS),
+						redirect: "error"
 					});
-					if (!res.ok) throw new Error(`${init?.method || "GET"} ${path} -> ${res.status} ${res.statusText}`);
+					if (!res.ok) {
+						const errText = await res.text().catch(() => "");
+						let errBody = void 0;
+						if (errText) try {
+							errBody = JSON.parse(errText);
+						} catch {
+							errBody = void 0;
+						}
+						throw new ProxyCallError(`${init?.method || "GET"} ${path} -> ${res.status} ${res.statusText}`, res.status, errBody);
+					}
 					const text = await res.text();
 					return text ? JSON.parse(text) : null;
 				}
 			};
 			cached = handle;
+			cachedUrl = url;
 			cachedAt = Date.now();
 			return handle;
 		}
 		const local = { mode: "local" };
 		cached = local;
+		cachedUrl = url;
 		cachedAt = Date.now();
 		return local;
 	})();
+	probeInFlight = {
+		url,
+		forceProxy: skipProbe,
+		promise: pending
+	};
 	try {
-		return await probeInFlight;
+		return await pending;
 	} finally {
-		probeInFlight = null;
+		if (probeInFlight?.promise === pending) probeInFlight = null;
 	}
 }
 //#endregion
@@ -379,6 +440,9 @@ function textResponse(payload, pretty = false) {
 		text: JSON.stringify(payload, null, pretty ? 2 : 0)
 	}] };
 }
+function isAuthenticationError(error) {
+	return error instanceof ProxyCallError && (error.status === 401 || error.status === 403);
+}
 function validate(toolName, args) {
 	if (!IMPLEMENTED_TOOLS.has(toolName)) throw new Error(`Unknown tool: ${toolName}`);
 	const v = { tool: toolName };
@@ -396,22 +460,41 @@ function validate(toolName, args) {
 		}
 		case "memory_recall":
 		case "memory_smart_search": {
+			if (args.targetLayer !== void 0 && !isSearchLayer(args.targetLayer)) throw new Error("targetLayer must be one of: all, memory, observation");
+			v.targetLayer = args.targetLayer ?? "all";
+			for (const field of [
+				"project",
+				"cwd",
+				"agentId",
+				"sessionId",
+				"source"
+			]) {
+				if (args[field] !== void 0 && typeof args[field] !== "string") throw new Error(`${field} must be a string`);
+				if (typeof args[field] === "string" && args[field].trim()) v[field] = args[field].trim();
+			}
+			if (toolName === "memory_smart_search") {
+				v.expandIds = parseSearchExpansionIds(args.expandIds);
+				if (typeof args.includeLessons === "boolean") v.includeLessons = args.includeLessons;
+			}
 			const query = args["query"];
-			if (typeof query !== "string" || !query.trim()) throw new Error("query is required");
-			v.query = query.trim();
+			if (typeof query !== "string" || !query.trim()) {
+				if (!v.expandIds?.length) throw new Error("query is required unless expandIds is provided");
+			} else v.query = query.trim();
 			v.limit = parseLimit(args["limit"]);
-			const fmt = args["format"];
-			if (typeof fmt === "string" && fmt.trim()) v.format = fmt.trim().toLowerCase();
-			const budget = args["token_budget"];
-			if (typeof budget === "number" && Number.isFinite(budget) && budget > 0) v.tokenBudget = Math.floor(budget);
-			else if (typeof budget === "string" && budget.trim()) {
-				const n = Number(budget);
-				if (Number.isFinite(n) && n > 0) v.tokenBudget = Math.floor(n);
+			if (toolName === "memory_recall") {
+				const format = typeof args.format === "string" ? args.format.trim().toLowerCase() : args.format ?? "full";
+				if (format !== "full" && format !== "compact" && format !== "narrative") throw new Error("format must be one of: full, compact, narrative");
+				v.format = format;
+				if (args.token_budget !== void 0) {
+					const budget = typeof args.token_budget === "string" ? Number(args.token_budget) : args.token_budget;
+					if (typeof budget !== "number" || !Number.isInteger(budget) || budget < 1) throw new Error("token_budget must be a positive integer");
+					v.tokenBudget = budget;
+				}
 			}
 			return v;
 		}
 		case "memory_sessions":
-			v.limit = parseLimit(args["limit"], 20);
+			v.sessionQuery = parseSessionArguments(args);
 			return v;
 		case "memory_governance_delete": {
 			const ids = normalizeList(args["memoryIds"]);
@@ -420,7 +503,22 @@ function validate(toolName, args) {
 			v.reason = args["reason"] || "plugin skill request";
 			return v;
 		}
-		case "memory_export": return v;
+		case "memory_export": {
+			const query = new URLSearchParams();
+			for (const key of [
+				"maxSessions",
+				"offset",
+				"collectionLimit",
+				"collectionOffset"
+			]) {
+				const n = Number(args[key]);
+				const min = key === "maxSessions" || key === "collectionLimit" ? 1 : 0;
+				if (args[key] !== void 0 && Number.isInteger(n) && n >= min) query.set(key, String(n));
+			}
+			if (typeof args["collections"] === "string") query.set("collections", args["collections"]);
+			v.exportQuery = query.toString();
+			return v;
+		}
 		case "memory_audit":
 			v.limit = parseLimit(args["limit"], 50);
 			return v;
@@ -444,7 +542,11 @@ async function handleProxy(v, handle) {
 			const body = {
 				query: v.query,
 				limit: v.limit,
-				format: v.format ?? "full"
+				format: v.format ?? "full",
+				targetLayer: v.targetLayer,
+				project: v.project,
+				cwd: v.cwd,
+				agentId: v.agentId
 			};
 			if (v.tokenBudget != null) body["token_budget"] = v.tokenBudget;
 			return textResponse(await handle.call("/agentmemory/search", {
@@ -455,16 +557,21 @@ async function handleProxy(v, handle) {
 		case "memory_smart_search": {
 			const body = {
 				query: v.query,
-				limit: v.limit
+				limit: v.limit,
+				targetLayer: v.targetLayer,
+				project: v.project,
+				agentId: v.agentId,
+				expandIds: v.expandIds,
+				sessionId: v.sessionId,
+				source: v.source,
+				includeLessons: v.includeLessons
 			};
-			if (v.format != null) body["format"] = v.format;
-			if (v.tokenBudget != null) body["token_budget"] = v.tokenBudget;
 			return textResponse(await handle.call("/agentmemory/smart-search", {
 				method: "POST",
 				body: JSON.stringify(body)
 			}), true);
 		}
-		case "memory_sessions": return textResponse(await handle.call(`/agentmemory/sessions?limit=${v.limit}`, { method: "GET" }), true);
+		case "memory_sessions": return textResponse(await handle.call(`/agentmemory/sessions?${new URLSearchParams(v.sessionQuery)}`, { method: "GET" }), true);
 		case "memory_governance_delete": return textResponse(await handle.call("/agentmemory/governance/memories", {
 			method: "DELETE",
 			body: JSON.stringify({
@@ -472,11 +579,23 @@ async function handleProxy(v, handle) {
 				reason: v.reason
 			})
 		}));
-		case "memory_export": return textResponse(await handle.call("/agentmemory/export", { method: "GET" }), true);
+		case "memory_export": try {
+			return textResponse(await handle.call(`/agentmemory/export${v.exportQuery ? `?${v.exportQuery}` : ""}`, { method: "GET" }), true);
+		} catch (err) {
+			if (err instanceof ProxyCallError && err.status === 413 && err.body != null && typeof err.body === "object" && err.body.oversized === true) return textResponse(err.body, true);
+			throw err;
+		}
 		case "memory_audit": return textResponse(await handle.call(`/agentmemory/audit?limit=${v.limit}`, { method: "GET" }), true);
 		default: throw new Error(`Unknown tool: ${v.tool}`);
 	}
 }
+function localFallbackNotice(persisted) {
+	const store = persisted ? "the local fallback file, which the server does not read" : "this process's in-memory fallback store, which is lost when the process exits";
+	return {
+		storage: "local",
+		warning: `agentmemory server at ${displayAgentmemoryUrl()} did not confirm this call, so it ran against ${store}.`
+	};
+}
 async function handleLocal(v, kvInstance) {
 	switch (v.tool) {
 		case "memory_save": {
@@ -494,34 +613,96 @@ async function handleLocal(v, kvInstance) {
 				strength: 7,
 				version: 1,
 				isLatest: true,
-				sessionIds: []
+				sessionIds: [],
+				...v.project !== void 0 && { project: v.project },
+				...(v.agentId ?? getAgentId()) !== void 0 && { agentId: v.agentId ?? getAgentId() }
+			});
+			return textResponse({
+				saved: id,
+				...localFallbackNotice(kvInstance.persist())
 			});
-			kvInstance.persist();
-			return textResponse({ saved: id });
 		}
 		case "memory_recall":
 		case "memory_smart_search": {
+			const isolated = isAgentScopeIsolated();
+			const agentId = v.agentId === "*" ? void 0 : v.agentId ?? (isolated ? getAgentId() : void 0);
+			if (isolated && v.agentId !== "*" && !agentId) throw new Error("AGENTMEMORY_AGENT_SCOPE=isolated requires an agentId; pass '*' to read across agents");
 			const query = (v.query || "").toLowerCase();
 			const limit = v.limit ?? DEFAULT_LIMIT;
+			const all = v.targetLayer === "observation" ? [] : await kvInstance.list("mem:memories");
+			const sessions = v.project || v.cwd ? await kvInstance.list("mem:sessions") : [];
+			const sessionsById = new Map(sessions.map((session) => [session.id, session]));
+			const scoped = all.filter((memory) => {
+				if (memory.isLatest === false || agentId && memory.agentId !== agentId) return false;
+				const linkedSessions = (memory.sessionIds ?? []).map((id) => sessionsById.get(id));
+				if (v.project && (memory.project ? memory.project !== v.project : !linkedSessions.some((session) => session?.project === v.project))) return false;
+				if (v.cwd && !linkedSessions.some((session) => session?.cwd === v.cwd)) return false;
+				return true;
+			});
+			if (v.tool === "memory_smart_search" && v.expandIds?.length) {
+				const ids = v.expandIds.map((entry) => typeof entry === "string" ? entry : entry.obsId);
+				const byId = new Map(scoped.map((memory) => [memory.id, memory]));
+				const eligible = ids.filter((id) => byId.has(id));
+				return textResponse({
+					mode: "expanded",
+					results: eligible.slice(0, 20).map((id) => {
+						const observation = memoryToObservation(byId.get(id));
+						return {
+							obsId: id,
+							sessionId: observation.sessionId,
+							observation,
+							layer: "memory"
+						};
+					}),
+					truncated: eligible.length > 20
+				}, true);
+			}
+			const results = scoped.filter((memory) => {
+				const text = [
+					memory.title,
+					memory.content,
+					...memory.files ?? [],
+					...memory.concepts ?? [],
+					...memory.sessionIds ?? [],
+					memory.id
+				].join(" ").toLowerCase();
+				return query.split(/\s+/).every((word) => text.includes(word));
+			}).slice(0, limit);
+			if (v.tool === "memory_recall") return textResponse(buildRecallResponse(results.map((memory) => {
+				const observation = memoryToObservation(memory);
+				return {
+					sessionId: observation.sessionId,
+					observation,
+					score: 1,
+					layer: "memory"
+				};
+			}), v.format ?? "full", v.tokenBudget), true);
 			return textResponse({
 				mode: "compact",
-				results: (await kvInstance.list("mem:memories")).filter((m) => {
-					const text = [
-						typeof m["title"] === "string" ? m["title"] : "",
-						typeof m["content"] === "string" ? m["content"] : "",
-						Array.isArray(m["files"]) ? m["files"].join(" ") : "",
-						Array.isArray(m["concepts"]) ? m["concepts"].join(" ") : "",
-						Array.isArray(m["sessionIds"]) ? m["sessionIds"].join(" ") : "",
-						typeof m["id"] === "string" ? m["id"] : ""
-					].join(" ").toLowerCase();
-					return query.split(/\s+/).every((word) => text.includes(word));
-				}).slice(0, limit)
+				results: results.map((memory) => ({
+					...memory,
+					obsId: memory.id,
+					sessionId: memory.sessionIds?.[0] ?? "memory",
+					layer: "memory"
+				}))
 			}, true);
 		}
 		case "memory_sessions": {
-			const sessions = await kvInstance.list("mem:sessions");
-			const limit = v.limit ?? 20;
-			return textResponse({ sessions: sessions.slice(0, limit) }, true);
+			const query = v.sessionQuery;
+			const agentId = query.agentId === "*" ? void 0 : query.agentId ?? (isAgentScopeIsolated() ? getAgentId() : void 0);
+			const sessions = (await kvInstance.list("mem:sessions")).filter((session) => session && typeof session.id === "string" && session.id.length > 0).filter((session) => !query.project || session.project === query.project).filter((session) => !agentId || session.agentId === agentId);
+			const key = (session) => session.startedAt || "";
+			const { page, nextCursor } = pageAfterCursor(sortByKeyDesc(sessions, key, (session) => session.id), key, (session) => session.id, query.cursor, Number(query.limit));
+			return textResponse({
+				sessions: await Promise.all(page.map(async (session) => {
+					const summary = await kvInstance.get("mem:summaries", session.id);
+					return summary ? {
+						...session,
+						summary
+					} : session;
+				})),
+				nextCursor
+			}, true);
 		}
 		case "memory_governance_delete": {
 			let deleted = 0;
@@ -529,11 +710,12 @@ async function handleLocal(v, kvInstance) {
 				await kvInstance.delete("mem:memories", id);
 				deleted++;
 			}
-			kvInstance.persist();
+			const persisted = kvInstance.persist();
 			return textResponse({
 				deleted,
 				requested: (v.memoryIds || []).length,
-				reason: v.reason
+				reason: v.reason,
+				...localFallbackNotice(persisted)
 			});
 		}
 		case "memory_export": return textResponse({
@@ -541,11 +723,7 @@ async function handleLocal(v, kvInstance) {
 			memories: await kvInstance.list("mem:memories"),
 			sessions: await kvInstance.list("mem:sessions")
 		}, true);
-		case "memory_audit": {
-			const entries = await kvInstance.list("mem:audit");
-			const limit = v.limit ?? 50;
-			return textResponse({ entries: entries.slice(0, limit) }, true);
-		}
+		case "memory_audit": return textResponse(await queryAudit(kvInstance, { limit: v.limit ?? 50 }), true);
 		default: throw new Error(`Unknown tool: ${v.tool}`);
 	}
 }
@@ -577,6 +755,10 @@ async function handleToolCall(toolName, args, kvInstance = kv) {
 	if (handle.mode === "proxy") try {
 		return await handleProxy(validated, handle);
 	} catch (err) {
+		if (toolName === "memory_sessions" || isAuthenticationError(err) || isProxyRequired()) {
+			invalidateHandle();
+			throw err;
+		}
 		process.stderr.write(`[@agentmemory/mcp] proxy call failed for ${toolName}: ${err instanceof Error ? err.message : String(err)}; invalidating handle and falling back to local KV\n`);
 		invalidateHandle();
 	}
@@ -597,10 +779,12 @@ async function handleToolsList() {
 			if (debug) process.stderr.write(`[@agentmemory/mcp] tools/list: returning ${remote.tools.length} tools from server\n`);
 			return { tools: remote.tools };
 		}
+		if (isProxyRequired()) throw new Error("AgentMemory returned an invalid tool inventory");
 		process.stderr.write(`[@agentmemory/mcp] tools/list: server returned unexpected shape (no .tools array); falling back to local IMPLEMENTED_TOOLS list. Set AGENTMEMORY_DEBUG=1 to inspect response.\n`);
 	} catch (err) {
-		process.stderr.write(`[@agentmemory/mcp] tools/list proxy failed: ${err instanceof Error ? err.message : String(err)}; falling back to local list\n`);
 		invalidateHandle();
+		if (isAuthenticationError(err) || isProxyRequired()) throw err;
+		process.stderr.write(`[@agentmemory/mcp] tools/list proxy failed: ${err instanceof Error ? err.message : String(err)}; falling back to local list\n`);
 	}
 	const fallback = getAllTools().filter((t) => IMPLEMENTED_TOOLS.has(t.name));
 	if (debug) process.stderr.write(`[@agentmemory/mcp] tools/list: returning ${fallback.length} local fallback tools (${fallback.map((t) => t.name).join(",")})\n`);
@@ -652,4 +836,4 @@ process.on("SIGTERM", () => {
 //#endregion
 export {};
 
-//# sourceMappingURL=standalone-BqNJDJ04.mjs.map
+//# sourceMappingURL=standalone-BlqshyZ5.mjs.map