@echomem/mcp 1.4.35 → 1.4.36

package/dist/codex-sync.js

@@ -132,7 +132,7 @@ function summarizeToolArgs(toolName, args) {
             tag_count: Array.isArray(args.tags) ? args.tags.length : undefined,
         };
     }
-    if (toolName === "get_memories_by_time_range" || toolName === "search_memories_by_time_range") {
+    if (toolName === "get_memories_by_time_range") {
         return {
             has_start_date: !!asString(args.startDate),
             has_end_date: !!asString(args.endDate),

package/dist/index.js

@@ -192,6 +192,56 @@ function readNumber(record, key) {
     const value = record[key];
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
+function normalizeQueryAlias(args) {
+    if (!isRecord(args) || !("conversation" in args))
+        return args;
+    const query = readString(args, "query") ?? readString(args, "conversation");
+    const { conversation: _ignored, ...rest } = args;
+    return query ? { ...rest, query } : rest;
+}
+const PERSONAL_RECALL_TOOL_NAMES = new Set([
+    canonicalToolNames.search,
+    canonicalToolNames.timeRange,
+    canonicalToolNames.keywords,
+]);
+function hasKeywordInput(args) {
+    const value = args.keywords;
+    if (Array.isArray(value)) {
+        return value.some((item) => typeof item === "string" && item.trim().length > 0);
+    }
+    return typeof value === "string" && value.trim().length > 0;
+}
+function routePersonalRecallInvocation(canonicalName, args) {
+    if (!PERSONAL_RECALL_TOOL_NAMES.has(canonicalName)) {
+        return { canonicalName, args };
+    }
+    const normalizedArgs = normalizeQueryAlias(args);
+    if (!isRecord(normalizedArgs)) {
+        return { canonicalName, args: normalizedArgs };
+    }
+    const hasSemanticInput = Boolean(readString(normalizedArgs, "query")
+        || readNumber(normalizedArgs, "timeFrameDays") !== undefined);
+    const hasKeywords = hasKeywordInput(normalizedArgs);
+    const hasDateRangeInput = Boolean(readString(normalizedArgs, "startDate") || readString(normalizedArgs, "endDate"));
+    const intentCount = Number(hasSemanticInput) + Number(hasKeywords) + Number(hasDateRangeInput);
+    if (intentCount > 1) {
+        return {
+            canonicalName,
+            args: normalizedArgs,
+            error: "Ambiguous memory search arguments. Use exactly one input shape: {query, optional timeFrameDays} for topic search, {keywords} for exact-key search, or {startDate, endDate} for a date range.",
+        };
+    }
+    if (hasSemanticInput) {
+        return { canonicalName: canonicalToolNames.search, args: normalizedArgs };
+    }
+    if (hasKeywords) {
+        return { canonicalName: canonicalToolNames.keywords, args: normalizedArgs };
+    }
+    if (hasDateRangeInput) {
+        return { canonicalName: canonicalToolNames.timeRange, args: normalizedArgs };
+    }
+    return { canonicalName, args: normalizedArgs };
+}
 function errorCodeFrom(value) {
     if (!isRecord(value))
         return undefined;
@@ -783,12 +833,12 @@ class EchoMemApiClient {
         };
     }
     async searchMemories(args, trace) {
-        const parsed = searchMemoriesSchema.parse(args ?? {});
+        const parsed = searchMemoriesSchema.parse(normalizeQueryAlias(args) ?? {});
         const query = parsed.query?.trim();
         const limit = parsed.limit ?? parsed.k ?? 10;
         const threshold = parsed.threshold ?? 0.1;
         if (!query && !parsed.timeFrameDays) {
-            throw new McpError(ErrorCode.InvalidParams, "Provide query, or provide timeFrameDays for chronological fetch.");
+            throw new McpError(ErrorCode.InvalidParams, "search_memories requires a non-empty query. For example: {\"query\":\"research article hero image\",\"timeFrameDays\":14}. For an explicit date range, call get_memories_by_time_range with both startDate and endDate.");
         }
         const enc = await this.encState(); // throws LockedError for an encrypted account without a key
         if (!query) {
@@ -1220,7 +1270,12 @@ class EchoMemMCPServer {
             return { tools: listToolSpecs({ map, groupMap, updateNotice }) };
         });
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const canonicalName = resolveCanonicalToolName(request.params.name);
+            const resolvedCanonicalName = resolveCanonicalToolName(request.params.name);
+            const recallRoute = routePersonalRecallInvocation(resolvedCanonicalName, request.params.arguments);
+            const canonicalName = recallRoute.canonicalName;
+            const toolArgs = canonicalName === canonicalToolNames.others
+                ? normalizeQueryAlias(recallRoute.args)
+                : recallRoute.args;
             const clientVersion = this.server.getClientVersion();
             this.mcpClientName = clientVersion?.name ?? this.mcpClientName;
             this.mcpClientVersion = clientVersion?.version ?? this.mcpClientVersion;
@@ -1235,8 +1290,8 @@ class EchoMemMCPServer {
                 conversation_id: this.client.getSessionId(),
                 tool_name: request.params.name,
                 canonical_tool_name: canonicalName,
-                ...triggerAnalyticsForTool(canonicalName, request.params.arguments),
-                ...inputAnalyticsForTool(canonicalName, request.params.arguments),
+                ...triggerAnalyticsForTool(canonicalName, toolArgs),
+                ...inputAnalyticsForTool(canonicalName, toolArgs),
             };
             const analyticsCallId = randomUUID();
             // One event per call. Handlers enrich `rec` with tool-specific detail; we finalize + log in `finally`.
@@ -1247,6 +1302,9 @@ class EchoMemMCPServer {
                 group_map_injected: this.groupMapInjected,
             };
             try {
+                if (recallRoute.error) {
+                    throw new McpError(ErrorCode.InvalidParams, recallRoute.error);
+                }
                 // The usage report is a local, $0 audit — works with no login (value before signup).
                 if (canonicalName === canonicalToolNames.report) {
                     return { content: [{ type: "text", text: await buildReportText(false) }] };
@@ -1315,17 +1373,17 @@ class EchoMemMCPServer {
                 }
                 switch (canonicalName) {
                     case canonicalToolNames.search:
-                        return await this.handleSearch(request.params.arguments, rec);
+                        return await this.handleSearch(toolArgs, rec);
                     case canonicalToolNames.save:
                         return await this.handleSave(request.params.arguments, rec);
                     case canonicalToolNames.timeRange:
-                        return await this.handleTimeRange(request.params.arguments);
+                        return await this.handleTimeRange(toolArgs);
                     case canonicalToolNames.getByContext:
                         return await this.handleGetByContext(request.params.arguments);
                     case canonicalToolNames.checkpointByContext:
                         return await this.handleGetCheckpointByContext(request.params.arguments);
                     case canonicalToolNames.keywords:
-                        return await this.handleKeywords(request.params.arguments);
+                        return await this.handleKeywords(toolArgs);
                     case canonicalToolNames.friends:
                         return await this.handleFriends(request.params.arguments);
                     case canonicalToolNames.searchUsers:
@@ -1333,7 +1391,7 @@ class EchoMemMCPServer {
                     case canonicalToolNames.sendFriendRequest:
                         return await this.handleSendFriendRequest(request.params.arguments);
                     case canonicalToolNames.others:
-                        return await this.handleOthers(request.params.arguments);
+                        return await this.handleOthers(toolArgs);
                     case canonicalToolNames.publicMemory:
                         return await this.handlePublicMemory(request.params.arguments);
                     case canonicalToolNames.recordCitations:

package/dist/v1-contract.js

@@ -34,7 +34,6 @@ export const canonicalToolNames = {
 };
 export const legacyAliasToCanonical = {
     search_memories_by_description_semantic: canonicalToolNames.search,
-    search_memories_by_time_range: canonicalToolNames.timeRange,
 };
 export function resolveCanonicalToolName(toolName) {
     return legacyAliasToCanonical[toolName] ?? toolName;
@@ -44,7 +43,6 @@ const READ_ONLY_TOOL_NAMES = new Set([
     canonicalToolNames.search,
     "search_memories_by_description_semantic",
     canonicalToolNames.timeRange,
-    "search_memories_by_time_range",
     canonicalToolNames.keywords,
     canonicalToolNames.friends,
     canonicalToolNames.searchUsers,
@@ -166,11 +164,11 @@ const triggerMetadataSchema = {
 };
 export const searchMemoriesSchema = z.object({
     ...triggerMetadataSchema,
-    query: z.string().optional(),
-    k: z.number().optional(),
-    limit: z.number().optional(),
-    threshold: z.number().optional().default(0.1),
-    timeFrameDays: z.number().optional(),
+    query: z.string().trim().min(1).optional(),
+    k: z.number().int().min(1).max(50).optional(),
+    limit: z.number().int().min(1).max(50).optional(),
+    threshold: z.number().min(0).max(1).optional().default(0.1),
+    timeFrameDays: z.number().int().min(1).max(3650).optional(),
     includeAnswer: z.boolean().optional().default(false),
 });
 export const saveConversationSchema = z.object({
@@ -189,11 +187,20 @@ export const saveConversationSchema = z.object({
     }))
         .optional(),
 });
+const dateBoundarySchema = z.string().trim().min(1).refine((value) => Number.isFinite(Date.parse(value)), "Expected an ISO-8601 date or date-time string");
 export const timeRangeSchema = z.object({
     ...triggerMetadataSchema,
-    startDate: z.string(),
-    endDate: z.string(),
-    limit: z.number().optional().default(50),
+    startDate: dateBoundarySchema,
+    endDate: dateBoundarySchema,
+    limit: z.number().int().min(1).max(100).optional().default(50),
+}).superRefine((value, ctx) => {
+    if (Date.parse(value.startDate) > Date.parse(value.endDate)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["startDate"],
+            message: "startDate must be earlier than or equal to endDate",
+        });
+    }
 });
 const keywordListSchema = z.preprocess((value) => {
     if (typeof value !== "string")
@@ -206,15 +213,15 @@ const keywordListSchema = z.preprocess((value) => {
 export const keywordsSchema = z.object({
     ...triggerMetadataSchema,
     keywords: keywordListSchema,
-    limit: z.number().optional().default(10),
+    limit: z.number().int().min(1).max(50).optional().default(10),
 });
 export const listFriendsSchema = z.object({
     ...triggerMetadataSchema,
 });
 export const searchUsersSchema = z.object({
     ...triggerMetadataSchema,
-    query: z.string().min(1),
-    limit: z.number().optional().default(10),
+    query: z.string().trim().min(1),
+    limit: z.number().int().min(1).max(50).optional().default(10),
 });
 export const sendFriendRequestSchema = z.object({
     ...triggerMetadataSchema,
@@ -222,17 +229,17 @@ export const sendFriendRequestSchema = z.object({
 });
 export const othersSchema = z.object({
     ...triggerMetadataSchema,
-    query: z.string().optional().default(""),
-    limit: z.number().optional().default(10),
+    query: z.string().trim().optional().default(""),
+    limit: z.number().int().min(1).max(50).optional().default(10),
     target: z.string().optional(),
     ownerUserId: z.string().optional(),
     ownerName: z.string().optional(),
     targetFriendIds: z.array(z.string()).optional(),
     targetFriendNames: z.array(z.string()).optional(),
     recordAccess: z.boolean().optional(),
-    kPerUser: z.number().optional(),
-    similarityThreshold: z.number().optional(),
-    timeFrameDays: z.number().optional(),
+    kPerUser: z.number().int().min(1).max(50).optional(),
+    similarityThreshold: z.number().min(0).max(1).optional(),
+    timeFrameDays: z.number().int().min(1).max(3650).optional(),
 });
 export const publicMemorySchema = z.object({
     ...triggerMetadataSchema,
@@ -329,8 +336,8 @@ export const deleteMemorySchema = z.object({
 });
 export const getByContextSchema = z.object({
     ...triggerMetadataSchema,
-    contextId: z.string().min(1),
-    limit: z.number().optional().default(50),
+    contextId: z.string().trim().min(1),
+    limit: z.number().int().min(1).max(100).optional().default(50),
 });
 export function listToolSpecs(opts = {}) {
     const currentTime = new Date().toISOString();
@@ -349,42 +356,64 @@ export function listToolSpecs(opts = {}) {
     const groupMapSection = groupMap
         ? `\n\nThis user's company group currently shares work in these areas (a relevance guide — search the group when the task relates to one of these people or topics):\n${compactGroupRoster(groupMap)}\n${groupMap}\n`
         : "";
+    const semanticSearchInputSchema = {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                minLength: 1,
+                description: "Required topic or question to search for. Never omit this field or send it as conversation.",
+            },
+            limit: { type: "integer", minimum: 1, maximum: 50, default: 10 },
+            threshold: { type: "number", minimum: 0, maximum: 1, default: 0.1 },
+            timeFrameDays: {
+                type: "integer",
+                minimum: 1,
+                maximum: 3650,
+                description: "Optional recency filter for this query, such as 14 for the last two weeks.",
+            },
+            triggerMessage: {
+                type: "string",
+                description: "Optional: the user's message that caused this recall. EchoMem stores only a redacted analytics preview and hash.",
+            },
+            triggerMessageRole: { type: "string", default: "user" },
+        },
+        required: ["query"],
+    };
+    const timeRangeInputSchema = {
+        type: "object",
+        properties: {
+            startDate: {
+                type: "string",
+                minLength: 1,
+                description: "Required ISO-8601 start date or date-time. Must not be later than endDate.",
+            },
+            endDate: {
+                type: "string",
+                minLength: 1,
+                description: "Required ISO-8601 end date or date-time. Must not be earlier than startDate.",
+            },
+            limit: { type: "integer", minimum: 1, maximum: 100, default: 50 },
+            triggerMessage: {
+                type: "string",
+                description: "Optional: the user's message that caused this lookup. EchoMem stores only a redacted analytics preview and hash.",
+            },
+            triggerMessageRole: { type: "string", default: "user" },
+        },
+        required: ["startDate", "endDate"],
+    };
     const tools = [
         {
             name: canonicalToolNames.search,
-            description: withMcpVersion(`Recall the user's prior decisions, preferences, and project context from EchoMem — their long-term memory across ALL their AI tools, not just this session. Use it instead of re-deriving or re-asking what the user already settled. ${recallPlanNote} ${searchBillingReplyInstruction} ${memoryCitationInstruction}${mapSection}\nReturns ranked memories only; the MCP host model writes the final answer. Current time: ${currentTime}.${updateSection}`),
-            inputSchema: {
-                type: "object",
-                properties: {
-                    query: { type: "string" },
-                    limit: { type: "number", default: 10 },
-                    threshold: { type: "number", default: 0.1 },
-                    timeFrameDays: { type: "number" },
-                    triggerMessage: {
-                        type: "string",
-                        description: "Optional: the user's message that caused this recall. EchoMem stores only a redacted analytics preview and hash.",
-                    },
-                    triggerMessageRole: { type: "string", default: "user" },
-                },
-            },
+            title: "Search your memories by topic",
+            description: withMcpVersion(`TOPIC SEARCH for the user's own EchoMem memories across all AI tools. Always pass a non-empty query; optionally add timeFrameDays to filter that topic to recent memories. Do not pass keywords, startDate, or endDate. For exact memory-key terms use search_memories_by_keywords. For an explicit calendar range use get_memories_by_time_range. Use this tool instead of re-deriving or re-asking what the user already settled. ${recallPlanNote} ${searchBillingReplyInstruction} ${memoryCitationInstruction}${mapSection}\nReturns ranked memories only; the MCP host model writes the final answer. Current time: ${currentTime}.${updateSection}`),
+            inputSchema: semanticSearchInputSchema,
         },
         {
             name: "search_memories_by_description_semantic",
-            description: `Legacy alias for search_memories. ${recallPlanNote} ${searchBillingReplyInstruction} ${memoryCitationInstruction}`,
-            inputSchema: {
-                type: "object",
-                properties: {
-                    query: { type: "string" },
-                    limit: { type: "number", default: 10 },
-                    threshold: { type: "number", default: 0.1 },
-                    timeFrameDays: { type: "number" },
-                    triggerMessage: {
-                        type: "string",
-                        description: "Optional: the user's message that caused this recall. EchoMem stores only a redacted analytics preview and hash.",
-                    },
-                    triggerMessageRole: { type: "string", default: "user" },
-                },
-            },
+            title: "Legacy topic search (compatibility)",
+            description: `LEGACY TOPIC SEARCH alias for search_memories. Prefer search_memories. Always pass a non-empty query; timeFrameDays is only an optional recency filter. Do not pass keywords, startDate, or endDate. ${recallPlanNote} ${searchBillingReplyInstruction} ${memoryCitationInstruction}`,
+            inputSchema: semanticSearchInputSchema,
         },
         {
             name: canonicalToolNames.save,
@@ -426,25 +455,14 @@ export function listToolSpecs(opts = {}) {
         },
         {
             name: canonicalToolNames.timeRange,
-            description: `Retrieve memories within a specific date range. ${recallPlanNote} ${memoryCitationInstruction} Current time: ${currentTime}.`,
-            inputSchema: {
-                type: "object",
-                properties: {
-                    startDate: { type: "string" },
-                    endDate: { type: "string" },
-                    limit: { type: "number", default: 50 },
-                    triggerMessage: {
-                        type: "string",
-                        description: "Optional: the user's message that caused this lookup. EchoMem stores only a redacted analytics preview and hash.",
-                    },
-                    triggerMessageRole: { type: "string", default: "user" },
-                },
-                required: ["startDate", "endDate"],
-            },
+            title: "Get your memories by date range",
+            description: `DATE-RANGE FETCH for the user's own memories. Always pass both startDate and endDate as ISO-8601 strings. Do not pass query, keywords, or timeFrameDays. For a topic with a recency filter use search_memories instead. ${recallPlanNote} ${memoryCitationInstruction} Current time: ${currentTime}.`,
+            inputSchema: timeRangeInputSchema,
         },
         {
             name: canonicalToolNames.keywords,
-            description: `Search memories based on keywords in keys field. Pass keywords as valid JSON: preferably an array of quoted strings, for example {"keywords":["flow-lab","flow.html","Rive"],"limit":8}. A comma-separated JSON string is also accepted as a compatibility fallback. Never emit bare comma-separated tokens. ${recallPlanNote} ${memoryCitationInstruction}`,
+            title: "Search your memory keys exactly",
+            description: `EXACT-KEYWORD SEARCH over the keys field of the user's own memories. Pass keywords as valid JSON: preferably an array of quoted strings, for example {"keywords":["flow-lab","flow.html","Rive"],"limit":8}. Do not pass query, timeFrameDays, startDate, or endDate. For natural-language topic search use search_memories. A comma-separated JSON string is accepted only as a compatibility fallback. Never emit bare comma-separated tokens. ${recallPlanNote} ${memoryCitationInstruction}`,
             inputSchema: {
                 type: "object",
                 properties: {
@@ -477,6 +495,7 @@ export function listToolSpecs(opts = {}) {
         },
         {
             name: canonicalToolNames.friends,
+            title: "List accepted EchoMem friends",
             description: "Friends: list accepted EchoMem friends with each friend's public memory count. Use this before asking a specific friend by name.",
             inputSchema: {
                 type: "object",
@@ -491,7 +510,8 @@ export function listToolSpecs(opts = {}) {
         },
         {
             name: canonicalToolNames.searchUsers,
-            description: "Search EchoMem users by display name/username before sending a friend request. Results include total memories, public memories, and current relationship state.",
+            title: "Search the EchoMem user directory",
+            description: "USER-DIRECTORY SEARCH by display name or username before sending a friend request. This searches people/accounts, not memory content. Results include total memories, public memories, and current relationship state.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -530,12 +550,16 @@ export function listToolSpecs(opts = {}) {
         },
         {
             name: canonicalToolNames.others,
-            description: `Search public memories from accepted friends or people who share your company group. EchoMem identifies the caller from the EchoMem credential and has already excluded only that authenticated user's own memories. Present every returned owner; never filter again using a Claude account, host profile, git identity, or inferred identity. For onboarding and division-of-work questions, call get_group_context first, then use this tool for current evidence. Returned memories are recorded in memory_views for the owners. ${memoryCitationInstruction}${groupMapSection}`,
+            title: "Search teammates' and friends' memories",
+            description: `PEER-MEMORY SEARCH for public memories owned by accepted friends or company-group members—not the user's own memories. Pass query for a topic; omit it only when intentionally browsing peer memories, and optionally use target to scope a person. Do not use this tool for the user's private memories or the EchoMem user directory. EchoMem identifies the caller from the EchoMem credential and has already excluded only that authenticated user's own memories. Present every returned owner; never filter again using a Claude account, host profile, git identity, or inference. For onboarding and division-of-work questions, call get_group_context first. Returned memories are recorded in memory_views for the owners. ${memoryCitationInstruction}${groupMapSection}`,
             inputSchema: {
                 type: "object",
                 properties: {
-                    query: { type: "string" },
-                    limit: { type: "number", default: 10 },
+                    query: {
+                        type: "string",
+                        description: "Optional peer-memory topic. Omit only for an intentional broad browse; never send this field as conversation.",
+                    },
+                    limit: { type: "integer", minimum: 1, maximum: 50, default: 10 },
                     target: {
                         type: "string",
                         description: "Accessible friend or group-member user id or exact display name. Prefer this for @Name asks.",
@@ -562,9 +586,9 @@ export function listToolSpecs(opts = {}) {
                         type: "boolean",
                         description: "Defaults true. When true, returned public memories are recorded in memory_views.",
                     },
-                    kPerUser: { type: "number", default: 5 },
-                    similarityThreshold: { type: "number", default: 0.1 },
-                    timeFrameDays: { type: "number" },
+                    kPerUser: { type: "integer", minimum: 1, maximum: 50, default: 5 },
+                    similarityThreshold: { type: "number", minimum: 0, maximum: 1, default: 0.1 },
+                    timeFrameDays: { type: "integer", minimum: 1, maximum: 3650 },
                     triggerMessage: {
                         type: "string",
                         description: "Optional: the user's message that caused this public-memory search. EchoMem stores only a redacted analytics preview and hash.",
@@ -575,6 +599,7 @@ export function listToolSpecs(opts = {}) {
         },
         {
             name: canonicalToolNames.publicMemory,
+            title: "Get one teammate or friend memory",
             description: `Fetch one public memory by id when its owner is an accepted friend or shares your company group. If the caller is not the owner, EchoMem records the access in memory_views. ${memoryCitationInstruction}`,
             inputSchema: {
                 type: "object",
@@ -892,6 +917,7 @@ export function listToolSpecs(opts = {}) {
         },
         {
             name: canonicalToolNames.getByContext,
+            title: "Get the exact memories from a saved context",
             description: withMcpVersion(`Deterministically re-fetch the exact batch of memories saved under one contextId — no semantic search, no ranking, just that session's saved capsule. ${recallPlanNote} save_conversation returns a contextId; pass it here to pull back precisely those memories, e.g. to warm up a fresh session with what a prior session saved, or to verify the saved facts are still present. ${memoryCitationInstruction} Current time: ${currentTime}.`),
             inputSchema: {
                 type: "object",
@@ -909,6 +935,7 @@ export function listToolSpecs(opts = {}) {
         },
         {
             name: canonicalToolNames.checkpointByContext,
+            title: "Rebuild a checkpoint from a saved context",
             description: withMcpVersion(`Rebuild a clean-context checkpoint / decision log from one EchoMem contextId. ${recallPlanNote} Use this when the user or EchoMem returns a contextId for a renewed coding session and you need the session handoff, not a raw memory dump. It deterministically fetches that context and formats it as orientation state: decisions, carryover, constraints, and checkpoints. ${memoryCitationInstruction} Current time: ${currentTime}.`),
             inputSchema: {
                 type: "object",
@@ -971,19 +998,6 @@ export function listToolSpecs(opts = {}) {
                 },
             },
         },
-        {
-            name: "search_memories_by_time_range",
-            description: "Legacy alias for get_memories_by_time_range.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    startDate: { type: "string" },
-                    endDate: { type: "string" },
-                    limit: { type: "number", default: 50 },
-                },
-                required: ["startDate", "endDate"],
-            },
-        },
     ];
     return tools.map(decorateLocalToolSpec);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@echomem/mcp",
-  "version": "1.4.35",
+  "version": "1.4.36",
   "description": "EchoMem MCP bridge: cloud-first memory tools and the Agent Doctor workspace forensics report (cost ledger + 3D repo city)",
   "main": "dist/index.js",
   "type": "module",