@mastra/server 1.12.0 → 1.13.0

package/dist/{observational-memory-YRWU6CY3-OSS4UPF4.cjs → observational-memory-XXD6E2SO-3I4EZBKC.cjs}

@@ -1002,7 +1002,7 @@ function getCharacterCount(text) {
   return Array.from(text).length;
 }
 
-// ../memory/dist/chunk-M7RAJAZ6.js
+// ../memory/dist/chunk-SUU4IAZJ.js
 function formatRelativeTime(date, currentDate) {
   const diffMs = currentDate.getTime() - date.getTime();
   const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
@@ -1781,6 +1781,11 @@ ${maybeTruncate(resultStr, maxLen)}`;
 ${maybeTruncate(argsStr, maxLen)}`;
       }
       const partType = part.type;
+      if (partType === "reasoning") {
+        const reasoning = part.reasoning;
+        if (reasoning) return maybeTruncate(reasoning, maxLen);
+        return "";
+      }
       if (partType === "image" || partType === "file") {
         const attachment = part;
         const inputAttachment = toObserverInputAttachmentPart(attachment);
@@ -1795,6 +1800,9 @@ ${maybeTruncate(argsStr, maxLen)}`;
   } else if (msg.content?.content) {
     content = maybeTruncate(msg.content.content, maxLen);
   }
+  if (!content && attachments.length === 0) {
+    return { text: "", attachments };
+  }
   return {
     text: `**${role}${timestampStr}:**
 ${content}`,
@@ -1803,18 +1811,21 @@ ${content}`,
 }
 function formatMessagesForObserver(messages, options) {
   const counter = { nextImageId: 1, nextFileId: 1 };
-  return messages.map((msg) => formatObserverMessage(msg, counter, options).text).join("\n\n---\n\n");
+  return messages.map((msg) => formatObserverMessage(msg, counter, options).text).filter(Boolean).join("\n\n---\n\n");
 }
 function buildObserverHistoryMessage(messages) {
   const counter = { nextImageId: 1, nextFileId: 1 };
   const content = [{ type: "text", text: "## New Message History to Observe\n\n" }];
-  messages.forEach((message, index) => {
+  let visibleCount = 0;
+  messages.forEach((message) => {
     const formatted = formatObserverMessage(message, counter);
-    content.push({ type: "text", text: formatted.text });
-    content.push(...formatted.attachments);
-    if (index < messages.length - 1) {
+    if (!formatted.text && formatted.attachments.length === 0) return;
+    if (visibleCount > 0) {
       content.push({ type: "text", text: "\n\n---\n\n" });
     }
+    content.push({ type: "text", text: formatted.text });
+    content.push(...formatted.attachments);
+    visibleCount++;
   });
   return {
     role: "user",
@@ -1843,16 +1854,22 @@ The following messages are from ${threadOrder.length} different conversation thr
   threadOrder.forEach((threadId, threadIndex) => {
     const messages = messagesByThread.get(threadId);
     if (!messages || messages.length === 0) return;
-    content.push({ type: "text", text: `<thread id="${threadId}">
-` });
-    messages.forEach((message, messageIndex) => {
+    const threadContent = [];
+    let visibleCount = 0;
+    messages.forEach((message) => {
       const formatted = formatObserverMessage(message, counter);
-      content.push({ type: "text", text: formatted.text });
-      content.push(...formatted.attachments);
-      if (messageIndex < messages.length - 1) {
-        content.push({ type: "text", text: "\n\n---\n\n" });
+      if (!formatted.text && formatted.attachments.length === 0) return;
+      if (visibleCount > 0) {
+        threadContent.push({ type: "text", text: "\n\n---\n\n" });
       }
+      threadContent.push({ type: "text", text: formatted.text });
+      threadContent.push(...formatted.attachments);
+      visibleCount++;
     });
+    if (visibleCount === 0) return;
+    content.push({ type: "text", text: `<thread id="${threadId}">
+` });
+    content.push(...threadContent);
     content.push({ type: "text", text: "\n</thread>" });
     if (threadIndex < threadOrder.length - 1) {
       content.push({ type: "text", text: "\n\n" });
@@ -1863,7 +1880,7 @@ The following messages are from ${threadOrder.length} different conversation thr
     content
   };
 }
-function buildMultiThreadObserverTaskPrompt(existingObservations) {
+function buildMultiThreadObserverTaskPrompt(existingObservations, threadOrder, priorMetadataByThread, wasTruncated) {
   let prompt = "";
   if (existingObservations) {
     prompt += `## Previous Observations
@@ -1875,6 +1892,39 @@ ${existingObservations}
 `;
     prompt += "Do not repeat these existing observations. Your new observations will be appended to the existing observations.\n\n";
   }
+  const hasTruncatedObservations = wasTruncated ?? false;
+  const threadMetadataLines = threadOrder?.map((threadId) => {
+    const metadata = priorMetadataByThread?.get(threadId);
+    if (!metadata?.currentTask && !metadata?.suggestedResponse) {
+      return "";
+    }
+    const lines = [`- thread ${threadId}`];
+    if (metadata.currentTask) {
+      lines.push(`  - prior current-task: ${metadata.currentTask}`);
+    }
+    if (metadata.suggestedResponse) {
+      lines.push(`  - prior suggested-response: ${metadata.suggestedResponse}`);
+    }
+    return lines.join("\n");
+  }).filter(Boolean).join("\n");
+  if (threadMetadataLines) {
+    prompt += `## Prior Thread Metadata
+
+${threadMetadataLines}
+
+`;
+    if (hasTruncatedObservations) {
+      prompt += `Previous observations were truncated for context budget reasons.
+`;
+      prompt += `The main agent still has full memory context outside this observer window.
+`;
+    }
+    prompt += `Use each thread's prior current-task and suggested-response as continuity hints, then update them based on that thread's new messages.
+
+---
+
+`;
+  }
   prompt += `## Your Task
 
 `;
@@ -1963,6 +2013,32 @@ ${existingObservations}
 `;
     prompt += "Do not repeat these existing observations. Your new observations will be appended to the existing observations.\n\n";
   }
+  const hasTruncatedObservations = options?.wasTruncated ?? false;
+  const priorMetadataLines = [];
+  if (options?.priorCurrentTask) {
+    priorMetadataLines.push(`- prior current-task: ${options.priorCurrentTask}`);
+  }
+  if (options?.priorSuggestedResponse) {
+    priorMetadataLines.push(`- prior suggested-response: ${options.priorSuggestedResponse}`);
+  }
+  if (priorMetadataLines.length > 0) {
+    prompt += `## Prior Thread Metadata
+
+${priorMetadataLines.join("\n")}
+
+`;
+    if (hasTruncatedObservations) {
+      prompt += `Previous observations were truncated for context budget reasons.
+`;
+      prompt += `The main agent still has full memory context outside this observer window.
+`;
+    }
+    prompt += `Use the prior current-task and suggested-response as continuity hints, then update them based on the new messages.
+
+---
+
+`;
+  }
   prompt += `## Your Task
 
 `;
@@ -4248,6 +4324,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         config.observation?.blockAfter ?? (config.observation?.bufferTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferTokens ? 1.2 : void 0),
         config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens
       ),
+      previousObserverTokens: config.observation?.previousObserverTokens ?? 2e3,
       instruction: config.observation?.instruction
     };
     this.reflectionConfig = {
@@ -4284,7 +4361,8 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
     return {
       scope: this.scope,
       observation: {
-        messageTokens: this.observationConfig.messageTokens
+        messageTokens: this.observationConfig.messageTokens,
+        previousObserverTokens: this.observationConfig.previousObserverTokens
       },
       reflection: {
         observationTokens: this.reflectionConfig.observationTokens
@@ -4364,7 +4442,8 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       scope: this.scope,
       observation: {
         messageTokens: this.observationConfig.messageTokens,
-        model: observationModelName
+        model: observationModelName,
+        previousObserverTokens: this.observationConfig.previousObserverTokens
       },
       reflection: {
         observationTokens: this.reflectionConfig.observationTokens,
@@ -4429,6 +4508,13 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         );
       }
     }
+    if (this.observationConfig.previousObserverTokens !== void 0 && this.observationConfig.previousObserverTokens !== false) {
+      if (!Number.isFinite(this.observationConfig.previousObserverTokens) || this.observationConfig.previousObserverTokens < 0) {
+        throw new Error(
+          `observation.previousObserverTokens must be false or a finite number >= 0, got ${this.observationConfig.previousObserverTokens}`
+        );
+      }
+    }
     if (this.reflectionConfig.bufferActivation !== void 0) {
       if (this.reflectionConfig.bufferActivation <= 0 || this.reflectionConfig.bufferActivation > 1) {
         throw new Error(
@@ -4826,6 +4912,141 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
     }
     return result;
   }
+  /**
+   * Prepare optimized observer context by applying truncation and buffered-reflection inclusion.
+   *
+   * Returns the (possibly optimized) observations string to pass as "Previous Observations"
+   * to the observer prompt. When no optimization options are set, returns the input unchanged.
+   */
+  prepareObserverContext(existingObservations, record) {
+    const { previousObserverTokens } = this.observationConfig;
+    const tokenBudget = previousObserverTokens === void 0 || previousObserverTokens === false ? void 0 : previousObserverTokens;
+    if (tokenBudget === void 0) {
+      return { context: existingObservations, wasTruncated: false };
+    }
+    const bufferedReflection = record?.bufferedReflection && record?.reflectedObservationLineCount ? record.bufferedReflection : void 0;
+    if (!existingObservations) {
+      return { context: bufferedReflection, wasTruncated: false };
+    }
+    let observations = existingObservations;
+    if (bufferedReflection && record?.reflectedObservationLineCount) {
+      const allLines = observations.split("\n");
+      const unreflectedLines = allLines.slice(record.reflectedObservationLineCount);
+      const unreflectedContent = unreflectedLines.join("\n").trim();
+      observations = unreflectedContent ? `${bufferedReflection}
+
+${unreflectedContent}` : bufferedReflection;
+    }
+    let wasTruncated = false;
+    if (tokenBudget !== void 0) {
+      if (tokenBudget === 0) {
+        return { context: "", wasTruncated: true };
+      }
+      const currentTokens = this.tokenCounter.countObservations(observations);
+      if (currentTokens > tokenBudget) {
+        observations = this.truncateObservationsToTokenBudget(observations, tokenBudget);
+        wasTruncated = true;
+      }
+    }
+    return { context: observations, wasTruncated };
+  }
+  /**
+   * Truncate observations to fit within a token budget.
+   *
+   * Strategy:
+   * 1. Keep a raw tail of recent observations (end of block).
+   * 2. Add a truncation marker: [X observations truncated here], placed at the hidden gap.
+   * 3. Try to preserve important observations (🔴) from older context, newest-first.
+   * 4. Enforce that at least 50% of kept observations remain raw tail observations.
+   */
+  truncateObservationsToTokenBudget(observations, budget) {
+    if (budget === 0) {
+      return "";
+    }
+    const totalTokens = this.tokenCounter.countObservations(observations);
+    if (totalTokens <= budget) {
+      return observations;
+    }
+    const lines = observations.split("\n");
+    const totalCount = lines.length;
+    const lineTokens = new Array(totalCount);
+    const isImportant = new Array(totalCount);
+    for (let i = 0; i < totalCount; i++) {
+      lineTokens[i] = this.tokenCounter.countString(lines[i]);
+      isImportant[i] = lines[i].includes("\u{1F534}");
+    }
+    const suffixTokens = new Array(totalCount + 1);
+    suffixTokens[totalCount] = 0;
+    for (let i = totalCount - 1; i >= 0; i--) {
+      suffixTokens[i] = suffixTokens[i + 1] + lineTokens[i];
+    }
+    const headImportantIndexes = [];
+    const buildCandidateString = (tailStart, selectedImportantIndexes) => {
+      const keptIndexes = [
+        ...selectedImportantIndexes,
+        ...Array.from({ length: totalCount - tailStart }, (_, i) => tailStart + i)
+      ].sort((a, b) => a - b);
+      if (keptIndexes.length === 0) {
+        return `[${totalCount} observations truncated here]`;
+      }
+      const outputLines = [];
+      let previousKeptIndex = -1;
+      for (const keptIndex of keptIndexes) {
+        const hiddenCount = keptIndex - previousKeptIndex - 1;
+        if (hiddenCount === 1) {
+          outputLines.push(lines[previousKeptIndex + 1]);
+        } else if (hiddenCount > 1) {
+          outputLines.push(`[${hiddenCount} observations truncated here]`);
+        }
+        outputLines.push(lines[keptIndex]);
+        previousKeptIndex = keptIndex;
+      }
+      const trailingHiddenCount = totalCount - previousKeptIndex - 1;
+      if (trailingHiddenCount === 1) {
+        outputLines.push(lines[totalCount - 1]);
+      } else if (trailingHiddenCount > 1) {
+        outputLines.push(`[${trailingHiddenCount} observations truncated here]`);
+      }
+      return outputLines.join("\n");
+    };
+    const estimateKeptContentCost = (tailStart, selectedImportantIndexes) => {
+      let cost = suffixTokens[tailStart];
+      for (const idx of selectedImportantIndexes) {
+        cost += lineTokens[idx];
+      }
+      return cost;
+    };
+    let bestCandidate;
+    let bestImportantCount = -1;
+    let bestRawTailLength = -1;
+    for (let tailStart = 1; tailStart < totalCount; tailStart++) {
+      if (isImportant[tailStart - 1]) {
+        headImportantIndexes.push(tailStart - 1);
+      }
+      const rawTailLength = totalCount - tailStart;
+      const maxImportantByRatio = rawTailLength;
+      let importantToKeep = Math.min(headImportantIndexes.length, maxImportantByRatio);
+      const getSelectedImportant = (count) => count > 0 ? headImportantIndexes.slice(Math.max(0, headImportantIndexes.length - count)) : [];
+      while (importantToKeep > 0 && estimateKeptContentCost(tailStart, getSelectedImportant(importantToKeep)) > budget) {
+        importantToKeep -= 1;
+      }
+      if (estimateKeptContentCost(tailStart, getSelectedImportant(importantToKeep)) > budget) {
+        continue;
+      }
+      if (importantToKeep > bestImportantCount || importantToKeep === bestImportantCount && rawTailLength > bestRawTailLength) {
+        const candidate = buildCandidateString(tailStart, getSelectedImportant(importantToKeep));
+        if (this.tokenCounter.countObservations(candidate) <= budget) {
+          bestCandidate = candidate;
+          bestImportantCount = importantToKeep;
+          bestRawTailLength = rawTailLength;
+        }
+      }
+    }
+    if (!bestCandidate) {
+      return `[${totalCount} observations truncated here]`;
+    }
+    return bestCandidate;
+  }
   /**
    * Call the Observer agent to extract observations.
    */
@@ -4834,12 +5055,17 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
     const observerMessages = [
       {
         role: "user",
-        content: buildObserverTaskPrompt(existingObservations, options)
+        content: buildObserverTaskPrompt(existingObservations, {
+          skipContinuationHints: options?.skipContinuationHints,
+          priorCurrentTask: options?.priorCurrentTask,
+          priorSuggestedResponse: options?.priorSuggestedResponse,
+          wasTruncated: options?.wasTruncated
+        })
       },
       buildObserverHistoryMessage(messagesToObserve)
     ];
     const doGenerate = async () => {
-      return this.withAbortCheck(async () => {
+      const result2 = await this.withAbortCheck(async () => {
         const streamResult = await agent.stream(observerMessages, {
           modelSettings: {
             ...this.observationConfig.modelSettings
@@ -4850,6 +5076,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         });
         return streamResult.getFullOutput();
       }, abortSignal);
+      return result2;
     };
     let result = await doGenerate();
     let parsed = parseObserverOutput(result.text);
@@ -4880,17 +5107,23 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
    * Returns per-thread results with observations, currentTask, and suggestedContinuation,
    * plus the total usage for the batch.
    */
-  async callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, abortSignal, requestContext) {
+  async callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, priorMetadataByThread, abortSignal, requestContext, wasTruncated) {
+    const systemPrompt = buildObserverSystemPrompt(true, this.observationConfig.instruction);
     const agent$1 = new agent.Agent({
       id: "multi-thread-observer",
       name: "multi-thread-observer",
       model: this.observationConfig.model,
-      instructions: buildObserverSystemPrompt(true, this.observationConfig.instruction)
+      instructions: systemPrompt
     });
     const observerMessages = [
       {
         role: "user",
-        content: buildMultiThreadObserverTaskPrompt(existingObservations)
+        content: buildMultiThreadObserverTaskPrompt(
+          existingObservations,
+          threadOrder,
+          priorMetadataByThread,
+          wasTruncated
+        )
       },
       buildMultiThreadObserverHistoryMessage(messagesByThread, threadOrder)
     ];
@@ -4902,7 +5135,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       this.observedMessageIds.add(msg.id);
     }
     const doGenerate = async () => {
-      return this.withAbortCheck(async () => {
+      const result2 = await this.withAbortCheck(async () => {
         const streamResult = await agent$1.stream(observerMessages, {
           modelSettings: {
             ...this.observationConfig.modelSettings
@@ -4913,6 +5146,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         });
         return streamResult.getFullOutput();
       }, abortSignal);
+      return result2;
     };
     let result = await doGenerate();
     let parsed = parseMultiThreadObserverOutput(result.text);
@@ -6346,12 +6580,18 @@ ${newThreadSection}`;
           );
         }
       }
-      const result = await this.callObserver(
+      const { context: observerContext, wasTruncated } = this.prepareObserverContext(
         freshRecord?.activeObservations ?? record.activeObservations,
-        messagesToObserve,
-        abortSignal,
-        { requestContext }
+        freshRecord ?? record
       );
+      const thread = await this.storage.getThreadById({ threadId });
+      const threadOMMetadata = memory.getThreadOMMetadata(thread?.metadata);
+      const result = await this.callObserver(observerContext, messagesToObserve, abortSignal, {
+        requestContext,
+        priorCurrentTask: threadOMMetadata?.currentTask,
+        priorSuggestedResponse: threadOMMetadata?.suggestedResponse,
+        wasTruncated
+      });
       const existingObservations = freshRecord?.activeObservations ?? record.activeObservations ?? "";
       let newObservations;
       if (this.scope === "resource") {
@@ -6368,16 +6608,16 @@ ${result.observations}` : result.observations;
       const newMessageIds = messagesToObserve.map((m) => m.id);
       const existingIds = freshRecord?.observedMessageIds ?? record.observedMessageIds ?? [];
       const allObservedIds = [.../* @__PURE__ */ new Set([...Array.isArray(existingIds) ? existingIds : [], ...newMessageIds])];
-      const thread = await this.storage.getThreadById({ threadId });
-      if (thread) {
-        const newMetadata = memory.setThreadOMMetadata(thread.metadata, {
+      const threadForMetadata = await this.storage.getThreadById({ threadId });
+      if (threadForMetadata) {
+        const newMetadata = memory.setThreadOMMetadata(threadForMetadata.metadata, {
           suggestedResponse: result.suggestedContinuation,
           currentTask: result.currentTask,
           lastObservedMessageCursor: this.getLastObservedMessageCursor(messagesToObserve)
         });
         await this.storage.updateThread({
           id: threadId,
-          title: thread.title ?? "",
+          title: threadForMetadata.title ?? "",
           metadata: newMetadata
         });
       }
@@ -6611,12 +6851,21 @@ ${result.observations}` : result.observations;
     const bufferedChunks = this.getBufferedChunks(record);
     const bufferedChunksText = bufferedChunks.map((c) => c.observations).join("\n\n");
     const combinedObservations = this.combineObservationsForBuffering(record.activeObservations, bufferedChunksText);
+    const { context: observerContext, wasTruncated } = this.prepareObserverContext(combinedObservations, record);
+    const thread = await this.storage.getThreadById({ threadId });
+    const threadOMMetadata = memory.getThreadOMMetadata(thread?.metadata);
     const result = await this.callObserver(
-      combinedObservations,
+      observerContext,
       messagesToBuffer,
       void 0,
       // No abort signal for background ops
-      { skipContinuationHints: true, requestContext }
+      {
+        skipContinuationHints: true,
+        requestContext,
+        priorCurrentTask: threadOMMetadata?.currentTask,
+        priorSuggestedResponse: threadOMMetadata?.suggestedResponse,
+        wasTruncated
+      }
     );
     if (!result.observations) {
       omDebug(`[OM:doAsyncBufferedObservation] empty observations returned, skipping buffer storage`);
@@ -6683,8 +6932,6 @@ ${result.observations}` : result.observations;
     }
     return `${activeObservations}
 
---- BUFFERED (pending activation) ---
-
 ${bufferedObservations}`;
   }
   /**
@@ -7044,7 +7291,11 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
     const threadMetadataMap = /* @__PURE__ */ new Map();
     for (const thread of allThreads) {
       const omMetadata = memory.getThreadOMMetadata(thread.metadata);
-      threadMetadataMap.set(thread.id, { lastObservedAt: omMetadata?.lastObservedAt });
+      threadMetadataMap.set(thread.id, {
+        lastObservedAt: omMetadata?.lastObservedAt,
+        currentTask: omMetadata?.currentTask,
+        suggestedResponse: omMetadata?.suggestedResponse
+      });
     }
     const messagesByThread = /* @__PURE__ */ new Map();
     for (const thread of allThreads) {
@@ -7124,7 +7375,12 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           return;
         }
       }
-      const existingObservations = freshRecord?.activeObservations ?? record.activeObservations ?? "";
+      const rawExistingObservations = freshRecord?.activeObservations ?? record.activeObservations ?? "";
+      const { context: optimizedObservations, wasTruncated } = this.prepareObserverContext(
+        rawExistingObservations,
+        freshRecord ?? record
+      );
+      const existingObservations = optimizedObservations ?? rawExistingObservations;
       for (const threadId of threadOrder) {
         const msgs = messagesByThread.get(threadId);
         if (msgs && msgs.length > 0) {
@@ -7188,12 +7444,24 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         batches.push(currentBatch);
       }
       const batchPromises = batches.map(async (batch) => {
+        const batchPriorMetadata = /* @__PURE__ */ new Map();
+        for (const threadId of batch.threadIds) {
+          const metadata = threadMetadataMap.get(threadId);
+          if (metadata?.currentTask || metadata?.suggestedResponse) {
+            batchPriorMetadata.set(threadId, {
+              currentTask: metadata.currentTask,
+              suggestedResponse: metadata.suggestedResponse
+            });
+          }
+        }
         const batchResult = await this.callMultiThreadObserver(
           existingObservations,
           batch.threadMap,
           batch.threadIds,
+          batchPriorMetadata,
           abortSignal,
-          requestContext
+          requestContext,
+          wasTruncated
         );
         return batchResult;
       });
@@ -7224,7 +7492,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           result
         });
       }
-      let currentObservations = existingObservations;
+      let currentObservations = rawExistingObservations;
       let cycleObservationTokens = 0;
       for (const obsResult of observationResults) {
         if (!obsResult) continue;
@@ -7691,5 +7959,5 @@ exports.formatMessagesForObserver = formatMessagesForObserver;
 exports.hasCurrentTaskSection = hasCurrentTaskSection;
 exports.optimizeObservationsForContext = optimizeObservationsForContext;
 exports.parseObserverOutput = parseObserverOutput;
-//# sourceMappingURL=observational-memory-YRWU6CY3-OSS4UPF4.cjs.map
-//# sourceMappingURL=observational-memory-YRWU6CY3-OSS4UPF4.cjs.map
+//# sourceMappingURL=observational-memory-XXD6E2SO-3I4EZBKC.cjs.map
+//# sourceMappingURL=observational-memory-XXD6E2SO-3I4EZBKC.cjs.map