@graphmemory/server 1.2.0 → 1.3.1

package/dist/lib/parsers/docs.js

@@ -4,9 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFile = parseFile;
+exports.clearWikiIndexCache = clearWikiIndexCache;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const codeblock_1 = require("../../lib/parsers/codeblock");
+const defaults_1 = require("../../lib/defaults");
 // Parse a markdown file into chunks split by headings
 async function parseFile(content, absolutePath, projectDir, chunkDepth) {
     const fileId = path_1.default.relative(projectDir, absolutePath);
@@ -119,8 +121,10 @@ function extractFileTitle(content, filePath) {
 function extractLinks(content, fromFile, projectDir) {
     const results = new Set();
     const fileDir = path_1.default.dirname(fromFile);
+    // Strip fenced code blocks before extracting links (links inside code are not real references)
+    const textOnly = content.replace(FENCE_RE, '');
     // [text](./path.md)
-    const mdLinks = content.matchAll(/\[[^\]]*\]\(([^)#\s]+)/g);
+    const mdLinks = textOnly.matchAll(/\[[^\]]*\]\(([^)#\s]+)/g);
     for (const [, href] of mdLinks) {
         if (isExternal(href))
             continue;
@@ -130,7 +134,7 @@ function extractLinks(content, fromFile, projectDir) {
             results.add(fileId);
     }
     // [[wiki link]] or [[wiki link|alias]]
-    const wikiLinks = content.matchAll(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g);
+    const wikiLinks = textOnly.matchAll(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g);
     for (const [, name] of wikiLinks) {
         const resolved = findWikiFile(name.trim(), projectDir);
         if (!resolved)
@@ -160,40 +164,65 @@ function toFileId(absolutePath, projectDir) {
         return path_1.default.relative(projectDir, withMd);
     return null;
 }
+/**
+ * Cache: projectDir → Map<lowercased basename (without .md), absolute path>.
+ * Built once per project via a single recursive walk, then reused for all wiki link lookups.
+ */
+const _wikiIndex = new Map();
+/** Clear cached wiki link index (call when files change or between projects). */
+function clearWikiIndexCache(projectDir) {
+    if (projectDir)
+        _wikiIndex.delete(projectDir);
+    else
+        _wikiIndex.clear();
+}
+function getWikiIndex(projectDir) {
+    if (_wikiIndex.has(projectDir))
+        return _wikiIndex.get(projectDir);
+    const index = new Map();
+    const MAX_DEPTH = defaults_1.WIKI_MAX_DEPTH;
+    function walk(dir, depth) {
+        if (depth >= MAX_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.isSymbolicLink())
+                continue;
+            const full = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full, depth + 1);
+            }
+            else if (entry.isFile()) {
+                // Index by basename without extension (lowercased)
+                const key = path_1.default.basename(entry.name, path_1.default.extname(entry.name)).toLowerCase();
+                if (!index.has(key))
+                    index.set(key, full);
+                // Also index by full filename (lowercased)
+                const fullKey = entry.name.toLowerCase();
+                if (!index.has(fullKey))
+                    index.set(fullKey, full);
+            }
+        }
+    }
+    walk(projectDir, 0);
+    _wikiIndex.set(projectDir, index);
+    return index;
+}
 function findWikiFile(name, projectDir) {
+    // Direct path check first (fast path)
     const direct = path_1.default.join(projectDir, name);
     if (fs_1.default.existsSync(direct))
         return direct;
     const withMd = direct + '.md';
     if (fs_1.default.existsSync(withMd))
         return withMd;
-    return searchRecursive(name, projectDir);
-}
-const MAX_SEARCH_DEPTH = 10;
-function searchRecursive(name, dir, depth = 0) {
-    if (depth >= MAX_SEARCH_DEPTH)
-        return null;
-    let entries;
-    try {
-        entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return null;
-    }
-    for (const entry of entries) {
-        if (entry.name.startsWith('.'))
-            continue;
-        const full = path_1.default.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            const found = searchRecursive(name, full, depth + 1);
-            if (found)
-                return found;
-        }
-        else if (entry.isFile()) {
-            if (entry.name === name || entry.name === `${name}.md` || path_1.default.basename(entry.name, '.md') === name) {
-                return full;
-            }
-        }
-    }
-    return null;
+    // Fall back to cached index lookup
+    const index = getWikiIndex(projectDir);
+    return index.get(name.toLowerCase()) ?? index.get(name.toLowerCase() + '.md') ?? null;
 }

package/dist/lib/parsers/languages/registry.js

@@ -48,7 +48,7 @@ function isLanguageSupported(languageName) {
 }
 /** Reusable parser per language (avoids WASM memory leak from creating Parser on every call). */
 const parsers = new Map();
-/** Parse source code with the appropriate language grammar. Returns root node or null. */
+/** Parse source code with the appropriate language grammar. Returns tree (caller must call tree.delete() when done) or null. */
 async function parseSource(code, languageName) {
     const entry = languages.get(languageName);
     if (!entry)
@@ -62,7 +62,7 @@ async function parseSource(code, languageName) {
         parsers.set(languageName, parser);
     }
     const tree = parser.parse(code);
-    return tree?.rootNode ?? null;
+    return tree ?? null;
 }
 /** Get the mapper for a language. Returns undefined for unsupported languages. */
 function getMapper(languageName) {

package/dist/lib/parsers/languages/typescript.js

@@ -2,22 +2,74 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerTypescript = registerTypescript;
 const registry_1 = require("./registry");
+const defaults_1 = require("../../../lib/defaults");
 /** Get the previous named sibling that is a JSDoc comment. */
 function getDocComment(node) {
-    let prev = node.previousSibling;
+    let prev = node.previousNamedSibling;
     while (prev && prev.type === 'comment' && !prev.text.startsWith('/**')) {
-        prev = prev.previousSibling;
+        prev = prev.previousNamedSibling;
     }
     if (prev && prev.type === 'comment' && prev.text.startsWith('/**')) {
         return prev.text.trim();
     }
     return '';
 }
-/** Build a signature: first line of the node text (truncated to 200 chars). */
-function buildSignature(node) {
-    const text = node.text ?? '';
-    const firstLine = text.split('\n')[0].trim();
-    return firstLine.length > 200 ? firstLine.slice(0, 200) + '…' : firstLine;
+/** Collapse whitespace and truncate. */
+function truncate(text, maxLen = defaults_1.SIGNATURE_MAX_LEN) {
+    const collapsed = text.replace(/\s+/g, ' ').trim();
+    return collapsed.length > maxLen ? collapsed.slice(0, maxLen) + '…' : collapsed;
+}
+/**
+ * Slice outerNode.text up to where bodyNode begins, using line-based
+ * slicing to avoid tree-sitter byte-offset vs JS char-offset mismatch
+ * (startIndex is UTF-8 bytes, String.slice uses UTF-16 code units).
+ */
+function sliceBeforeBody(outerNode, bodyNode) {
+    const text = outerNode.text ?? '';
+    const outerStartRow = outerNode.startPosition.row;
+    const bodyStartRow = bodyNode.startPosition.row;
+    if (bodyStartRow > outerStartRow) {
+        const lines = text.split('\n');
+        const relativeRow = bodyStartRow - outerStartRow;
+        const beforeBody = lines.slice(0, relativeRow);
+        const bodyLine = lines[relativeRow] ?? '';
+        const braceIdx = bodyLine.indexOf('{');
+        if (braceIdx >= 0)
+            beforeBody.push(bodyLine.slice(0, braceIdx));
+        return beforeBody.join('\n');
+    }
+    const braceIdx = text.indexOf('{');
+    if (braceIdx > 0)
+        return text.slice(0, braceIdx);
+    return null;
+}
+/**
+ * Build signature by taking everything before the body node.
+ * Falls back to first line if no body found.
+ */
+function buildSignature(outerNode, innerNode) {
+    const bodyNode = innerNode.childForFieldName('body');
+    const text = outerNode.text ?? '';
+    if (!bodyNode)
+        return truncate(text);
+    const header = sliceBeforeBody(outerNode, bodyNode);
+    return truncate(header ?? text.split('\n')[0]);
+}
+/**
+ * Build signature for variable declarations.
+ * If value is arrow/function, strip the function body.
+ */
+function buildVariableSignature(outerNode, declarator) {
+    const value = declarator.childForFieldName('value');
+    if (value) {
+        const valueBody = value.childForFieldName('body');
+        if (valueBody) {
+            const header = sliceBeforeBody(outerNode, valueBody);
+            if (header)
+                return truncate(header);
+        }
+    }
+    return truncate(outerNode.text ?? '');
 }
 /** Build the full body text for a symbol. Includes JSDoc + node text. */
 function buildBody(node, docComment) {
@@ -26,10 +78,6 @@ function buildBody(node, docComment) {
     }
     return node.text ?? '';
 }
-/** Build a signature: always use the code declaration, not JSDoc. */
-function buildFullSignature(node, _docComment) {
-    return buildSignature(node);
-}
 /** Check if a node is inside an export_statement. */
 function isExported(node) {
     const parent = node.parent;
@@ -49,76 +97,171 @@ function startLine(node) {
 function endLine(node) {
     return (node.endPosition?.row ?? 0) + 1;
 }
+/**
+ * Extract the base type name from a type node, handling generic types.
+ * `Foo` → "Foo", `Foo<T>` (generic_type) → "Foo"
+ */
+function extractTypeName(node) {
+    if (node.type === 'identifier' || node.type === 'type_identifier') {
+        return node.text;
+    }
+    if (node.type === 'generic_type') {
+        const name = node.childForFieldName('name') ?? node.namedChildren?.[0];
+        if (name && (name.type === 'identifier' || name.type === 'type_identifier')) {
+            return name.text;
+        }
+    }
+    return null;
+}
 // ---------------------------------------------------------------------------
 // Symbol extraction
 // ---------------------------------------------------------------------------
-function extractClassSymbol(node) {
-    const outer = getOuterNode(node);
-    const doc = getDocComment(outer);
-    const name = node.childForFieldName('name')?.text ?? '';
-    const body = node.childForFieldName('body');
-    // Extract methods
+/** Extract class members: methods, fields, getters/setters. */
+function extractClassMembers(body) {
     const children = [];
-    if (body) {
-        for (const member of body.namedChildren) {
-            if (member.type === 'method_definition') {
+    if (!body)
+        return children;
+    for (const member of body.namedChildren) {
+        switch (member.type) {
+            case 'method_definition':
+            case 'abstract_method_definition':
+            case 'abstract_method_signature': {
                 const methodName = member.childForFieldName('name')?.text ?? '';
                 if (!methodName)
                     continue;
                 const methodDoc = getDocComment(member);
                 children.push({
                     name: methodName,
-                    kind: 'method',
-                    signature: buildSignature(member),
+                    kind: methodName === 'constructor' ? 'constructor' : 'method',
+                    signature: buildSignature(member, member),
                     docComment: methodDoc,
                     body: buildBody(member, methodDoc),
                     startLine: startLine(member),
                     endLine: endLine(member),
                     isExported: false,
                 });
+                break;
+            }
+            case 'public_field_definition':
+            case 'property_definition': {
+                const fieldName = member.childForFieldName('name')?.text ?? '';
+                if (!fieldName)
+                    continue;
+                const fieldDoc = getDocComment(member);
+                children.push({
+                    name: fieldName,
+                    kind: 'variable',
+                    signature: truncate(member.text ?? ''),
+                    docComment: fieldDoc,
+                    body: buildBody(member, fieldDoc),
+                    startLine: startLine(member),
+                    endLine: endLine(member),
+                    isExported: false,
+                });
+                break;
             }
         }
     }
+    return children;
+}
+function extractClassSymbol(node) {
+    const outer = getOuterNode(node);
+    const doc = getDocComment(outer);
+    const name = node.childForFieldName('name')?.text ?? '';
+    const body = node.childForFieldName('body');
+    const children = extractClassMembers(body);
     return {
         name,
         kind: 'class',
-        signature: buildFullSignature(outer, doc),
+        signature: buildSignature(outer, node),
         docComment: doc,
         body: buildBody(outer, doc),
         startLine: startLine(outer),
         endLine: endLine(outer),
         isExported: isExported(node),
-        children,
+        children: children.length > 0 ? children : undefined,
     };
 }
+/** Extract nested named function declarations from a function body (1 level deep). */
+function extractNestedFunctions(body) {
+    const nested = [];
+    if (!body || body.type !== 'statement_block')
+        return nested;
+    for (const stmt of body.namedChildren) {
+        if (stmt.type === 'function_declaration') {
+            const childName = stmt.childForFieldName('name')?.text;
+            if (!childName)
+                continue;
+            const childDoc = getDocComment(stmt);
+            nested.push({
+                name: childName,
+                kind: 'function',
+                signature: buildSignature(stmt, stmt),
+                docComment: childDoc,
+                body: buildBody(stmt, childDoc),
+                startLine: startLine(stmt),
+                endLine: endLine(stmt),
+                isExported: false,
+            });
+        }
+    }
+    return nested;
+}
 function extractFunctionSymbol(node) {
     const outer = getOuterNode(node);
     const doc = getDocComment(outer);
     const name = node.childForFieldName('name')?.text ?? '';
+    const body = node.childForFieldName('body');
+    const children = extractNestedFunctions(body);
     return {
         name,
         kind: 'function',
-        signature: buildFullSignature(outer, doc),
+        signature: buildSignature(outer, node),
         docComment: doc,
         body: buildBody(outer, doc),
         startLine: startLine(outer),
         endLine: endLine(outer),
         isExported: isExported(node),
+        children: children.length > 0 ? children : undefined,
     };
 }
 function extractInterfaceSymbol(node) {
     const outer = getOuterNode(node);
     const doc = getDocComment(outer);
     const name = node.childForFieldName('name')?.text ?? '';
+    // Extract interface members
+    const children = [];
+    const body = node.childForFieldName('body');
+    if (body) {
+        for (const member of body.namedChildren) {
+            if (member.type === 'property_signature' || member.type === 'method_signature') {
+                const memberName = member.childForFieldName('name')?.text ?? '';
+                if (!memberName)
+                    continue;
+                const memberDoc = getDocComment(member);
+                children.push({
+                    name: memberName,
+                    kind: member.type === 'method_signature' ? 'method' : 'variable',
+                    signature: truncate(member.text ?? ''),
+                    docComment: memberDoc,
+                    body: buildBody(member, memberDoc),
+                    startLine: startLine(member),
+                    endLine: endLine(member),
+                    isExported: false,
+                });
+            }
+        }
+    }
     return {
         name,
         kind: 'interface',
-        signature: buildFullSignature(outer, doc),
+        signature: buildSignature(outer, node),
         docComment: doc,
         body: buildBody(outer, doc),
         startLine: startLine(outer),
         endLine: endLine(outer),
         isExported: isExported(node),
+        children: children.length > 0 ? children : undefined,
     };
 }
 function extractTypeAliasSymbol(node) {
@@ -128,7 +271,7 @@ function extractTypeAliasSymbol(node) {
     return {
         name,
         kind: 'type',
-        signature: buildFullSignature(outer, doc),
+        signature: truncate(outer.text ?? ''),
         docComment: doc,
         body: buildBody(outer, doc),
         startLine: startLine(outer),
@@ -143,7 +286,7 @@ function extractEnumSymbol(node) {
     return {
         name,
         kind: 'enum',
-        signature: buildFullSignature(outer, doc),
+        signature: buildSignature(outer, node),
         docComment: doc,
         body: buildBody(outer, doc),
         startLine: startLine(outer),
@@ -155,7 +298,6 @@ function extractVariableSymbols(node, exported) {
     const outer = exported ? node.parent : node;
     const doc = getDocComment(outer);
     const symbols = [];
-    // Find all variable_declarator children
     for (const child of node.namedChildren) {
         if (child.type === 'variable_declarator') {
             const name = child.childForFieldName('name')?.text ?? '';
@@ -163,15 +305,24 @@ function extractVariableSymbols(node, exported) {
                 continue;
             const value = child.childForFieldName('value');
             const isArrow = value?.type === 'arrow_function' || value?.type === 'function_expression';
+            // Extract nested named functions from arrow/function body
+            let children;
+            if (isArrow && value) {
+                const fnBody = value.childForFieldName('body');
+                const nested = extractNestedFunctions(fnBody);
+                if (nested.length > 0)
+                    children = nested;
+            }
             symbols.push({
                 name,
                 kind: isArrow ? 'function' : 'variable',
-                signature: buildFullSignature(outer, doc),
+                signature: buildVariableSignature(outer, child),
                 docComment: doc,
                 body: buildBody(outer, doc),
                 startLine: startLine(outer),
                 endLine: endLine(outer),
                 isExported: exported,
+                children,
             });
         }
     }
@@ -182,13 +333,15 @@ function extractVariableSymbols(node, exported) {
 // ---------------------------------------------------------------------------
 function processTopLevel(node) {
     switch (node.type) {
-        case 'function_declaration': {
+        case 'function_declaration':
+        case 'function_signature': {
             const name = node.childForFieldName('name')?.text;
             if (!name)
                 return [];
             return [extractFunctionSymbol(node)];
         }
-        case 'class_declaration': {
+        case 'class_declaration':
+        case 'abstract_class_declaration': {
             const name = node.childForFieldName('name')?.text;
             if (!name)
                 return [];
@@ -218,6 +371,17 @@ function processTopLevel(node) {
             }
             return [];
         }
+        case 'ambient_declaration': {
+            // declare function/class/interface/etc — unwrap and process inner declaration
+            for (const child of node.namedChildren) {
+                if (child.type === 'comment')
+                    continue;
+                const results = processTopLevel(child);
+                if (results.length > 0)
+                    return results;
+            }
+            return [];
+        }
         default:
             return [];
     }
@@ -233,27 +397,27 @@ const typescriptMapper = {
     extractEdges(rootNode) {
         const edges = [];
         function findClasses(node) {
-            if (node.type === 'class_declaration') {
+            if (node.type === 'class_declaration' || node.type === 'abstract_class_declaration') {
                 const className = node.childForFieldName('name')?.text;
                 if (!className)
                     return;
-                // Look for class_heritage
                 for (const child of node.namedChildren) {
                     if (child.type === 'class_heritage') {
                         for (const clause of child.namedChildren) {
                             if (clause.type === 'extends_clause') {
-                                // First named child is the base class
                                 for (const c of clause.namedChildren) {
-                                    if (c.type === 'identifier' || c.type === 'type_identifier') {
-                                        edges.push({ fromName: className, toName: c.text, kind: 'extends' });
-                                        break;
+                                    const typeName = extractTypeName(c);
+                                    if (typeName) {
+                                        edges.push({ fromName: className, toName: typeName, kind: 'extends' });
+                                        break; // Only one base class
                                     }
                                 }
                             }
                             if (clause.type === 'implements_clause') {
                                 for (const c of clause.namedChildren) {
-                                    if (c.type === 'type_identifier' || c.type === 'identifier') {
-                                        edges.push({ fromName: className, toName: c.text, kind: 'implements' });
+                                    const typeName = extractTypeName(c);
+                                    if (typeName) {
+                                        edges.push({ fromName: className, toName: typeName, kind: 'implements' });
                                     }
                                 }
                             }
@@ -271,14 +435,20 @@ const typescriptMapper = {
     extractImports(rootNode) {
         const imports = [];
         for (const child of rootNode.children) {
+            // import statements
             if (child.type === 'import_statement') {
                 const source = child.childForFieldName('source');
                 if (source) {
-                    // Remove quotes from string literal
                     const specifier = source.text.replace(/^['"]|['"]$/g, '');
-                    if (specifier.startsWith('./') || specifier.startsWith('../')) {
-                        imports.push({ specifier });
-                    }
+                    imports.push({ specifier });
+                }
+            }
+            // Re-exports: export { ... } from '...' and export * from '...'
+            if (child.type === 'export_statement') {
+                const source = child.childForFieldName('source');
+                if (source) {
+                    const specifier = source.text.replace(/^['"]|['"]$/g, '');
+                    imports.push({ specifier });
                 }
             }
         }
@@ -293,10 +463,8 @@ function registerTypescript() {
     if (_registered)
         return;
     _registered = true;
-    // TypeScript and TSX share the same mapper
     (0, registry_1.registerLanguage)('typescript', 'tree-sitter-typescript.wasm', typescriptMapper);
     (0, registry_1.registerLanguage)('tsx', 'tree-sitter-tsx.wasm', typescriptMapper);
-    // JavaScript and JSX use the same mapper (TS is a superset)
     (0, registry_1.registerLanguage)('javascript', 'tree-sitter-javascript.wasm', typescriptMapper);
     (0, registry_1.registerLanguage)('jsx', 'tree-sitter-javascript.wasm', typescriptMapper);
 }

package/dist/lib/project-manager.js

@@ -13,11 +13,14 @@ const file_index_1 = require("../graphs/file-index");
 const task_1 = require("../graphs/task");
 const skill_1 = require("../graphs/skill");
 const indexer_1 = require("../cli/indexer");
+const code_2 = require("../lib/parsers/code");
+const docs_2 = require("../lib/parsers/docs");
 const promise_queue_1 = require("../lib/promise-queue");
 const multi_config_1 = require("../lib/multi-config");
 const mirror_watcher_1 = require("../lib/mirror-watcher");
 const team_1 = require("../lib/team");
 const path_1 = __importDefault(require("path"));
+const defaults_1 = require("../lib/defaults");
 // ---------------------------------------------------------------------------
 // ProjectManager
 // ---------------------------------------------------------------------------
@@ -264,6 +267,9 @@ class ProjectManager extends events_1.EventEmitter {
         const instance = this.projects.get(id);
         if (!instance)
             throw new Error(`Project "${id}" not found`);
+        // Clear parser caches to prevent cross-project leaks in multi-project mode
+        (0, code_2.clearPathMappingsCache)();
+        (0, docs_2.clearWikiIndexCache)();
         const gc = instance.config.graphConfigs;
         const indexer = (0, indexer_1.createProjectIndexer)(instance.docGraph, instance.codeGraph, {
             projectId: id,
@@ -287,17 +293,21 @@ class ProjectManager extends events_1.EventEmitter {
         this.saveProject(instance);
         instance.dirty = false;
         // Scan and watch .notes/ and .tasks/ for reverse import (skip for workspace projects — handled by workspace)
+        // Skip mirror entirely if knowledge or tasks graph is readonly (mirror requires both)
         if (instance.mirrorTracker && !instance.workspaceId && instance.knowledgeManager && instance.taskManager) {
-            const mirrorConfig = {
-                projectDir: instance.config.projectDir,
-                knowledgeManager: instance.knowledgeManager,
-                taskManager: instance.taskManager,
-                skillManager: instance.skillManager,
-                mutationQueue: instance.mutationQueue,
-                tracker: instance.mirrorTracker,
-            };
-            await (0, mirror_watcher_1.scanMirrorDirs)(mirrorConfig);
-            instance.mirrorWatcher = (0, mirror_watcher_1.startMirrorWatcher)(mirrorConfig);
+            const gc = instance.config.graphConfigs;
+            if (!gc.knowledge.readonly && !gc.tasks.readonly) {
+                const mirrorConfig = {
+                    projectDir: instance.config.projectDir,
+                    knowledgeManager: instance.knowledgeManager,
+                    taskManager: instance.taskManager,
+                    skillManager: gc.skills.readonly ? undefined : instance.skillManager,
+                    mutationQueue: instance.mutationQueue,
+                    tracker: instance.mirrorTracker,
+                };
+                await (0, mirror_watcher_1.scanMirrorDirs)(mirrorConfig);
+                instance.mirrorWatcher = (0, mirror_watcher_1.startMirrorWatcher)(mirrorConfig);
+            }
         }
         this.emit('project:indexed', { projectId: id });
         process.stderr.write(`[project-manager] Project "${id}" indexed\n`);
@@ -354,7 +364,7 @@ class ProjectManager extends events_1.EventEmitter {
     /**
      * Start auto-save interval (every intervalMs, save dirty projects).
      */
-    startAutoSave(intervalMs = 30_000) {
+    startAutoSave(intervalMs = defaults_1.AUTO_SAVE_INTERVAL_MS) {
         this.autoSaveInterval = setInterval(() => {
             for (const instance of this.projects.values()) {
                 if (instance.dirty) {