@mastra/convex 1.3.2 → 1.4.0-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @mastra/convex
 
+## 1.4.0-alpha.0
+
+### Minor Changes
+
+- Added Observational Memory support to the Convex storage adapter. Agents using `ConvexStore` can now enable `observationalMemory` in `@mastra/memory`, including async observation buffering and reflections. ([#19474](https://github.com/mastra-ai/mastra/pull/19474))
+
+  To enable it, add the new `mastraObservationalMemoryTable` to your Convex schema and redeploy:
+
+  ```ts title="convex/schema.ts"
+  import { defineSchema } from 'convex/server';
+  import {
+    mastraThreadsTable,
+    mastraMessagesTable,
+    mastraResourcesTable,
+    mastraObservationalMemoryTable,
+    // ...other Mastra tables
+  } from '@mastra/convex/schema';
+
+  export default defineSchema({
+    mastra_threads: mastraThreadsTable,
+    mastra_messages: mastraMessagesTable,
+    mastra_resources: mastraResourcesTable,
+    mastra_observational_memory: mastraObservationalMemoryTable,
+    // ...other Mastra tables
+  });
+  ```
+
+  Then run `npx convex deploy` (or `npx convex dev`) so the new table and storage operations are live. All observational memory writes run inside the deployed Convex storage mutation, so buffered-observation swaps and reflection generations are atomic.
+
+### Patch Changes
+
+- Improved type safety of the Convex storage layer. Table names accepted by the internal ConvexDB are now a closed union (core storage tables plus the observational memory table) instead of any string, so table-name typos are caught at compile time instead of silently routing records to the mastra_documents fallback table. The internal observational memory operations no longer take a table-name argument. ([#19485](https://github.com/mastra-ai/mastra/pull/19485))
+
+- Removed the Convex adapters' only Node builtin dependency. ConvexStore, the vector adapters, and the storage domains now use the Web Crypto API (crypto.randomUUID) instead of importing node:crypto, so @mastra/convex itself no longer requires the Node.js runtime ("use node") to bundle inside a Convex project. ([#19498](https://github.com/mastra-ai/mastra/pull/19498))
+
+- Updated dependencies [[`8a0d145`](https://github.com/mastra-ai/mastra/commit/8a0d145aadbdf7278665aceaaec364b35dd9bd94), [`bd2f1d2`](https://github.com/mastra-ai/mastra/commit/bd2f1d274d05e60e2366f005ea0d94d5cea0d5ff), [`21a0eb8`](https://github.com/mastra-ai/mastra/commit/21a0eb86746ba0b703acea360d4f84c6a5a493f2), [`de86fd7`](https://github.com/mastra-ai/mastra/commit/de86fd7119f0438381d1a642e3d258143c0b9c29), [`2745031`](https://github.com/mastra-ai/mastra/commit/2745031d1d4a4978f037092da371428c32e2842a), [`db650ce`](https://github.com/mastra-ai/mastra/commit/db650ce490348914e85b93651d83acdf8f2a4c31), [`6354eeb`](https://github.com/mastra-ai/mastra/commit/6354eeb32efa9f5f68f51dda394e90e2ee76f1fb)]:
+  - @mastra/core@1.51.1-alpha.0
+
 ## 1.3.2
 
 ### Patch Changes

package/README.md

@@ -2,7 +2,7 @@
 
 Convex adapters for Mastra:
 
-- `ConvexStore` implements the Mastra storage contract (threads, messages, workflows, scores, resources, schedules, channels, background tasks).
+- `ConvexStore` implements the Mastra storage contract (threads, messages, workflows, scores, resources, schedules, channels, background tasks, observational memory).
 - `ConvexVector` stores embeddings inside Convex and performs development-scale cosine similarity search.
 - `ConvexNativeVector` uses Convex native vector search for production workloads.
 - `ConvexServerCache` stores Mastra server cache entries in Convex for durable stream replay and response caching.
@@ -33,6 +33,7 @@ import {
   mastraChannelInstallationsTable,
   mastraChannelConfigTable,
   mastraBackgroundTasksTable,
+  mastraObservationalMemoryTable,
   mastraVectorIndexesTable,
   mastraVectorsTable,
   mastraCacheTable,
@@ -51,6 +52,7 @@ export default defineSchema({
   mastra_channel_installations: mastraChannelInstallationsTable,
   mastra_channel_config: mastraChannelConfigTable,
   mastra_background_tasks: mastraBackgroundTasksTable,
+  mastra_observational_memory: mastraObservationalMemoryTable,
   mastra_vector_indexes: mastraVectorIndexesTable,
   mastra_vectors: mastraVectorsTable,
   mastra_cache: mastraCacheTable,
@@ -170,22 +172,23 @@ Native vector search uses Convex's schema-defined vector indexes and action-only
 
 This adapter uses **typed Convex tables** for each Mastra domain:
 
-| Domain           | Convex Table                                            | Purpose                          |
-| ---------------- | ------------------------------------------------------- | -------------------------------- |
-| Threads          | `mastra_threads`                                        | Conversation threads             |
-| Messages         | `mastra_messages`                                       | Chat messages                    |
-| Resources        | `mastra_resources`                                      | User working memory              |
-| Workflows        | `mastra_workflow_snapshots`                             | Workflow state                   |
-| Scorers          | `mastra_scorers`                                        | Evaluation data                  |
-| Schedules        | `mastra_schedules`                                      | Workflow schedules               |
-| Triggers         | `mastra_schedule_triggers`                              | Schedule history                 |
-| Channels         | `mastra_channel_installations`, `mastra_channel_config` | Channel installations and config |
-| Background Tasks | `mastra_background_tasks`                               | Background task state            |
-| Vector Indexes   | `mastra_vector_indexes`                                 | Index metadata                   |
-| Vectors          | `mastra_vectors`                                        | Embeddings                       |
-| Cache            | `mastra_cache`                                          | Cache metadata                   |
-| Cache Items      | `mastra_cache_list_items`                               | Cache list entries               |
-| Fallback         | `mastra_documents`                                      | Unknown tables                   |
+| Domain               | Convex Table                                            | Purpose                          |
+| -------------------- | ------------------------------------------------------- | -------------------------------- |
+| Threads              | `mastra_threads`                                        | Conversation threads             |
+| Messages             | `mastra_messages`                                       | Chat messages                    |
+| Resources            | `mastra_resources`                                      | User working memory              |
+| Workflows            | `mastra_workflow_snapshots`                             | Workflow state                   |
+| Scorers              | `mastra_scorers`                                        | Evaluation data                  |
+| Schedules            | `mastra_schedules`                                      | Workflow schedules               |
+| Triggers             | `mastra_schedule_triggers`                              | Schedule history                 |
+| Channels             | `mastra_channel_installations`, `mastra_channel_config` | Channel installations and config |
+| Background Tasks     | `mastra_background_tasks`                               | Background task state            |
+| Observational Memory | `mastra_observational_memory`                           | Observational memory generations |
+| Vector Indexes       | `mastra_vector_indexes`                                 | Index metadata                   |
+| Vectors              | `mastra_vectors`                                        | Embeddings                       |
+| Cache                | `mastra_cache`                                          | Cache metadata                   |
+| Cache Items          | `mastra_cache_list_items`                               | Cache list entries               |
+| Fallback             | `mastra_documents`                                      | Unknown tables                   |
 
 All typed tables include:
 
@@ -196,6 +199,14 @@ Schedule due reads and trigger-history reads use bounded Convex queries to avoid
 
 Background task reads and updates also tolerate older rows that were written to the fallback `mastra_documents` table.
 
+### Observational memory
+
+`ConvexStore` supports Mastra's observational memory. Records are keyed by a `lookupKey` (`thread:{id}` or `resource:{id}`) and the latest generation is served through the `by_lookup_key` index. All observational memory read-modify-write operations run inside the deployed storage mutation, so swaps and counter updates are atomic.
+
+Upgrading from a version without observational memory: add `mastraObservationalMemoryTable` to your `convex/schema.ts` (as shown in the quick start) and run `npx convex deploy` again.
+
+Active observations and buffered chunks share one Convex document, which is subject to Convex's 1 MiB document size limit. Default observational memory thresholds stay well below this limit; extremely large custom thresholds can exceed it.
+
 ## Testing
 
 Set the following environment variables before running tests:

package/dist/{chunk-6P3LEDHY.cjs → chunk-PKCUPSKO.cjs}

@@ -267,6 +267,10 @@ var TABLE_INDEX_MAP = {
   mastra_vector_indexes: [
     { name: "by_name", fields: ["indexName"] },
     { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_observational_memory: [
+    { name: "by_lookup_key", fields: ["lookupKey", "generationCount"] },
+    { name: "by_record_id", fields: ["id"] }
   ]
 };
 function findBestIndex(convexTable, filters) {
@@ -296,6 +300,299 @@ function findBestIndex(convexTable, filters) {
   return best ? { indexName: best.indexName, indexedFilters: best.indexedFilters } : null;
 }
 
+// src/server/observational-memory.ts
+var OM_QUERY_MAX_DOCS = 1e4;
+function parseStoredChunks(value) {
+  if (typeof value !== "string" || !value) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function selectActivationBoundary(chunks, opts) {
+  const retentionFloor = opts.messageTokensThreshold * (1 - opts.activationRatio);
+  const targetMessageTokens = Math.max(0, opts.currentPendingTokens - retentionFloor);
+  let cumulativeMessageTokens = 0;
+  let bestOverBoundary = 0;
+  let bestOverTokens = 0;
+  let bestUnderBoundary = 0;
+  let bestUnderTokens = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
+    const boundary = i + 1;
+    if (cumulativeMessageTokens >= targetMessageTokens) {
+      if (bestOverBoundary === 0 || cumulativeMessageTokens < bestOverTokens) {
+        bestOverBoundary = boundary;
+        bestOverTokens = cumulativeMessageTokens;
+      }
+    } else {
+      if (cumulativeMessageTokens > bestUnderTokens) {
+        bestUnderBoundary = boundary;
+        bestUnderTokens = cumulativeMessageTokens;
+      }
+    }
+  }
+  const maxOvershoot = retentionFloor * 0.95;
+  const overshoot = bestOverTokens - targetMessageTokens;
+  const remainingAfterOver = opts.currentPendingTokens - bestOverTokens;
+  const remainingAfterUnder = opts.currentPendingTokens - bestUnderTokens;
+  const minRemaining = Math.min(1e3, retentionFloor);
+  if (opts.forceMaxActivation && bestOverBoundary > 0 && remainingAfterOver >= minRemaining) {
+    return bestOverBoundary;
+  }
+  if (bestOverBoundary > 0 && overshoot <= maxOvershoot && remainingAfterOver >= minRemaining) {
+    return bestOverBoundary;
+  }
+  if (bestUnderBoundary > 0 && remainingAfterUnder >= minRemaining) {
+    return bestUnderBoundary;
+  }
+  if (bestOverBoundary > 0) {
+    return bestOverBoundary;
+  }
+  return 1;
+}
+function mergeReflectionWithUnreflected(activeObservations, bufferedReflection, reflectedLineCount) {
+  const allLines = (activeObservations || "").split("\n");
+  const unreflectedLines = allLines.slice(reflectedLineCount);
+  const unreflectedContent = unreflectedLines.join("\n").trim();
+  return unreflectedContent ? `${bufferedReflection}
+
+${unreflectedContent}` : bufferedReflection;
+}
+function isPlainObj(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMergeOMConfig(target, source) {
+  const output = { ...target };
+  for (const key of Object.keys(source)) {
+    const tVal = target[key];
+    const sVal = source[key];
+    if (isPlainObj(tVal) && isPlainObj(sVal)) {
+      output[key] = deepMergeOMConfig(tVal, sVal);
+    } else if (sVal !== void 0) {
+      output[key] = sVal;
+    }
+  }
+  return output;
+}
+function parseJsonObject(value) {
+  if (typeof value !== "string" || !value) return {};
+  try {
+    const parsed = JSON.parse(value);
+    return isPlainObj(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function findRecordById(ctx, convexTable, id) {
+  return await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
+}
+function requireRecord(doc, id) {
+  if (!doc) {
+    throw new Error(`Observational memory record not found: ${id}`);
+  }
+  return doc;
+}
+var EMPTY_SWAP_RESULT = {
+  chunksActivated: 0,
+  messageTokensActivated: 0,
+  observationTokensActivated: 0,
+  messagesActivated: 0,
+  activatedCycleIds: [],
+  activatedMessageIds: []
+};
+async function handleObservationalMemoryOperation(ctx, convexTable, request) {
+  switch (request.op) {
+    case "omGetLatest": {
+      const doc = await ctx.db.query(convexTable).withIndex("by_lookup_key", (q) => q.eq("lookupKey", request.lookupKey)).order("desc").first();
+      return { ok: true, result: doc ?? null };
+    }
+    case "omGetHistory": {
+      let docs = await ctx.db.query(convexTable).withIndex("by_lookup_key", (q) => q.eq("lookupKey", request.lookupKey)).order("desc").take(OM_QUERY_MAX_DOCS);
+      if (request.from) {
+        docs = docs.filter((doc) => typeof doc.createdAt === "string" && doc.createdAt >= request.from);
+      }
+      if (request.to) {
+        docs = docs.filter((doc) => typeof doc.createdAt === "string" && doc.createdAt <= request.to);
+      }
+      if (request.offset != null) {
+        docs = docs.slice(request.offset);
+      }
+      return { ok: true, result: docs.slice(0, request.limit) };
+    }
+    case "omUpdateActive": {
+      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+      const safeTokenCount = Number.isFinite(request.tokenCount) && request.tokenCount >= 0 ? request.tokenCount : 0;
+      await ctx.db.patch(doc._id, {
+        activeObservations: request.observations,
+        lastObservedAt: request.lastObservedAt,
+        // Reset pending tokens since we've now observed them
+        pendingMessageTokens: 0,
+        observationTokenCount: safeTokenCount,
+        totalTokensObserved: Number(doc.totalTokensObserved || 0) + safeTokenCount,
+        observedMessageIds: request.observedMessageIds,
+        updatedAt: request.updatedAt
+      });
+      return { ok: true };
+    }
+    case "omAppendBufferedChunk": {
+      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+      const chunks = parseStoredChunks(doc.bufferedObservationChunks);
+      chunks.push(request.chunk);
+      const patch = {
+        bufferedObservationChunks: JSON.stringify(chunks),
+        updatedAt: request.updatedAt
+      };
+      if (request.lastBufferedAtTime) {
+        patch.lastBufferedAtTime = request.lastBufferedAtTime;
+      }
+      await ctx.db.patch(doc._id, patch);
+      return { ok: true };
+    }
+    case "omSwapBuffered": {
+      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+      const persistedChunks = parseStoredChunks(doc.bufferedObservationChunks);
+      if (persistedChunks.length === 0) {
+        return { ok: true, result: EMPTY_SWAP_RESULT };
+      }
+      const chunks = Array.isArray(request.bufferedChunks) ? request.bufferedChunks : persistedChunks;
+      if (chunks.length === 0) {
+        return { ok: true, result: EMPTY_SWAP_RESULT };
+      }
+      const chunksToActivate = selectActivationBoundary(chunks, {
+        activationRatio: request.activationRatio,
+        messageTokensThreshold: request.messageTokensThreshold,
+        currentPendingTokens: request.currentPendingTokens,
+        forceMaxActivation: request.forceMaxActivation
+      });
+      const activatedChunks = chunks.slice(0, chunksToActivate);
+      const remainingChunks = chunks.slice(chunksToActivate);
+      const activatedContent = activatedChunks.map((c) => c.observations).join("\n\n");
+      const activatedTokens = activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0);
+      const activatedMessageTokens = activatedChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
+      const activatedMessageCount = activatedChunks.reduce((sum, c) => sum + (c.messageIds?.length ?? 0), 0);
+      const activatedCycleIds = activatedChunks.map((c) => c.cycleId).filter((id) => !!id);
+      const activatedMessageIds = activatedChunks.flatMap((c) => c.messageIds ?? []);
+      const latestChunk = activatedChunks[activatedChunks.length - 1];
+      const lastObservedAt = request.lastObservedAt ?? latestChunk?.lastObservedAt ?? request.now;
+      const existingActive = doc.activeObservations || "";
+      const boundary = `
+
+--- message boundary (${lastObservedAt}) ---
+
+`;
+      const newActive = existingActive ? `${existingActive}${boundary}${activatedContent}` : activatedContent;
+      await ctx.db.patch(doc._id, {
+        activeObservations: newActive,
+        observationTokenCount: Number(doc.observationTokenCount || 0) + activatedTokens,
+        // Decrement pending message tokens (clamped to zero)
+        pendingMessageTokens: Math.max(0, Number(doc.pendingMessageTokens || 0) - activatedMessageTokens),
+        bufferedObservationChunks: remainingChunks.length > 0 ? JSON.stringify(remainingChunks) : null,
+        lastObservedAt,
+        updatedAt: request.now
+      });
+      const latestChunkHints = activatedChunks[activatedChunks.length - 1];
+      return {
+        ok: true,
+        result: {
+          chunksActivated: activatedChunks.length,
+          messageTokensActivated: activatedMessageTokens,
+          observationTokensActivated: activatedTokens,
+          messagesActivated: activatedMessageCount,
+          activatedCycleIds,
+          activatedMessageIds,
+          observations: activatedContent,
+          perChunk: activatedChunks.map((c) => ({
+            cycleId: c.cycleId ?? "",
+            messageTokens: c.messageTokens ?? 0,
+            observationTokens: c.tokenCount,
+            messageCount: c.messageIds?.length ?? 0,
+            observations: c.observations
+          })),
+          suggestedContinuation: latestChunkHints?.suggestedContinuation ?? void 0,
+          currentTask: latestChunkHints?.currentTask ?? void 0
+        }
+      };
+    }
+    case "omUpdateBufferedReflection": {
+      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+      const existingContent = doc.bufferedReflection || "";
+      await ctx.db.patch(doc._id, {
+        bufferedReflection: existingContent ? `${existingContent}
+
+${request.reflection}` : request.reflection,
+        bufferedReflectionTokens: Number(doc.bufferedReflectionTokens || 0) + request.tokenCount,
+        bufferedReflectionInputTokens: Number(doc.bufferedReflectionInputTokens || 0) + request.inputTokenCount,
+        reflectedObservationLineCount: request.reflectedObservationLineCount,
+        updatedAt: request.updatedAt
+      });
+      return { ok: true };
+    }
+    case "omSwapBufferedReflection": {
+      const { currentRecord, newId, tokenCount, now } = request;
+      const doc = requireRecord(await findRecordById(ctx, convexTable, currentRecord.id), currentRecord.id);
+      const bufferedReflection = doc.bufferedReflection || "";
+      if (!bufferedReflection) {
+        throw new Error("No buffered reflection to swap");
+      }
+      const newObservations = mergeReflectionWithUnreflected(
+        doc.activeObservations || "",
+        bufferedReflection,
+        Number(doc.reflectedObservationLineCount || 0)
+      );
+      const newRecord = {
+        id: newId,
+        lookupKey: currentRecord.lookupKey,
+        scope: currentRecord.scope,
+        resourceId: currentRecord.resourceId,
+        threadId: currentRecord.threadId,
+        activeObservations: newObservations,
+        activeObservationsPendingUpdate: null,
+        originType: "reflection",
+        config: currentRecord.config,
+        generationCount: currentRecord.generationCount + 1,
+        lastObservedAt: currentRecord.lastObservedAt,
+        lastReflectionAt: now,
+        pendingMessageTokens: 0,
+        totalTokensObserved: currentRecord.totalTokensObserved,
+        observationTokenCount: tokenCount,
+        isObserving: false,
+        isReflecting: false,
+        isBufferingObservation: false,
+        isBufferingReflection: false,
+        lastBufferedAtTokens: 0,
+        lastBufferedAtTime: null,
+        observedTimezone: currentRecord.observedTimezone,
+        metadata: currentRecord.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+      await ctx.db.insert(convexTable, newRecord);
+      await ctx.db.patch(doc._id, {
+        bufferedReflection: null,
+        bufferedReflectionTokens: null,
+        bufferedReflectionInputTokens: null,
+        reflectedObservationLineCount: null,
+        updatedAt: now
+      });
+      return { ok: true, result: newRecord };
+    }
+    case "omUpdateConfig": {
+      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+      const existing = parseJsonObject(doc.config);
+      const incoming = parseJsonObject(request.config);
+      const merged = deepMergeOMConfig(existing, incoming);
+      await ctx.db.patch(doc._id, {
+        config: JSON.stringify(merged),
+        updatedAt: request.updatedAt
+      });
+      return { ok: true };
+    }
+  }
+}
+
 // src/server/workflow-snapshot.ts
 var PENDING_MARKER_KEY = "__mastra_pending__";
 function isPendingMarker(val) {
@@ -375,6 +672,7 @@ var VECTOR_TABLE_PREFIX = "mastra_vector_";
 var CONVEX_TABLE_WORKFLOW_SNAPSHOTS = "mastra_workflow_snapshots";
 var CONVEX_TABLE_BACKGROUND_TASKS = "mastra_background_tasks";
 var CONVEX_TABLE_DOCUMENTS = "mastra_documents";
+var CONVEX_TABLE_OBSERVATIONAL_MEMORY = "mastra_observational_memory";
 var STORAGE_MUTATION_BATCH_SIZE = 25;
 var LOAD_MANY_MAX_IDS_PER_REQUEST = 10;
 var DEFAULT_SCHEDULE_QUERY_LIMIT = 100;
@@ -527,6 +825,8 @@ function resolveTable(tableName) {
       return { convexTable: CONVEX_TABLE_BACKGROUND_TASKS, isTyped: true };
     case TABLE_VECTOR_INDEXES:
       return { convexTable: "mastra_vector_indexes", isTyped: true };
+    case CONVEX_TABLE_OBSERVATIONAL_MEMORY:
+      return { convexTable: CONVEX_TABLE_OBSERVATIONAL_MEMORY, isTyped: true };
     default:
       if (tableName.startsWith(VECTOR_TABLE_PREFIX)) {
         return { convexTable: "mastra_vectors", isTyped: true };
@@ -587,6 +887,19 @@ function mergeMetadata(existing, update) {
 }
 async function handleTypedOperation(ctx, convexTable, request) {
   switch (request.op) {
+    case "omGetLatest":
+    case "omGetHistory":
+    case "omUpdateActive":
+    case "omAppendBufferedChunk":
+    case "omSwapBuffered":
+    case "omUpdateBufferedReflection":
+    case "omSwapBufferedReflection":
+    case "omUpdateConfig": {
+      if (convexTable !== CONVEX_TABLE_OBSERVATIONAL_MEMORY) {
+        throw new Error(`${request.op} is only supported for ${CONVEX_TABLE_OBSERVATIONAL_MEMORY}`);
+      }
+      return handleObservationalMemoryOperation(ctx, convexTable, request);
+    }
     case "createSchedule": {
       if (convexTable !== "mastra_schedules") {
         throw new Error(`createSchedule is only supported for mastra_schedules`);
@@ -1459,5 +1772,5 @@ exports.mastraNativeVectorAction = mastraNativeVectorAction;
 exports.mastraNativeVectorMutation = mastraNativeVectorMutation;
 exports.mastraNativeVectorQuery = mastraNativeVectorQuery;
 exports.mastraStorage = mastraStorage;
-//# sourceMappingURL=chunk-6P3LEDHY.cjs.map
-//# sourceMappingURL=chunk-6P3LEDHY.cjs.map
+//# sourceMappingURL=chunk-PKCUPSKO.cjs.map
+//# sourceMappingURL=chunk-PKCUPSKO.cjs.map