@adhisang/minecraft-modding-mcp 3.0.0 → 3.1.1

package/dist/source-service.js

@@ -159,6 +159,7 @@ function clampLimit(limit, fallback, max) {
 }
 const MAX_REGEX_QUERY_LENGTH = 200;
 const MAX_REGEX_RESULT_LIMIT = 100;
+const TRACE_LIFECYCLE_MAX_CONCURRENCY = 3;
 function normalizePathStyle(path) {
     return path.replaceAll("\\", "/");
 }
@@ -214,6 +215,18 @@ function normalizeOptionalProjectPath(projectPath) {
     const normalized = normalizePathForHost(trimmed, undefined, "projectPath");
     return isAbsolute(normalized) ? normalized : resolvePath(process.cwd(), normalized);
 }
+function looksLikeClassSegment(name) {
+    const trimmed = name.trim();
+    return /^[A-Z_$]/.test(trimmed);
+}
+function looksLikeJvmMethodDescriptor(descriptor) {
+    const trimmed = descriptor?.trim();
+    if (!trimmed || !trimmed.startsWith("(")) {
+        return false;
+    }
+    const closing = trimmed.indexOf(")");
+    return closing > 0 && closing < trimmed.length - 1;
+}
 function resolveGradleUserHomePath() {
     const configured = process.env.GRADLE_USER_HOME?.trim();
     if (!configured) {
@@ -278,16 +291,19 @@ function scopeToJarType(scope) {
 }
 function parseQualifiedMethodSymbol(symbol) {
     const trimmed = symbol.trim();
-    const separator = trimmed.lastIndexOf(".");
-    if (separator <= 0 || separator >= trimmed.length - 1) {
+    const descriptorStart = trimmed.indexOf("(");
+    const qualifiedSymbol = descriptorStart >= 0 ? trimmed.slice(0, descriptorStart) : trimmed;
+    const inlineDescriptor = descriptorStart >= 0 ? trimmed.slice(descriptorStart).trim() : undefined;
+    const separator = qualifiedSymbol.lastIndexOf(".");
+    if (separator <= 0 || separator >= qualifiedSymbol.length - 1) {
         throw createError({
             code: ERROR_CODES.INVALID_INPUT,
             message: `symbol must be in the form "fully.qualified.Class.method".`,
             details: { symbol }
         });
     }
-    const className = trimmed.slice(0, separator);
-    const methodName = trimmed.slice(separator + 1);
+    const className = qualifiedSymbol.slice(0, separator);
+    const methodName = qualifiedSymbol.slice(separator + 1);
     if (!className ||
         !methodName ||
         className.includes("/") ||
@@ -299,7 +315,11 @@ function parseQualifiedMethodSymbol(symbol) {
             details: { symbol }
         });
     }
-    return { className, methodName };
+    return {
+        className,
+        methodName,
+        ...(inlineDescriptor ? { inlineDescriptor } : {})
+    };
 }
 function normalizeOptionalString(value) {
     if (value == null) {
@@ -308,6 +328,27 @@ function normalizeOptionalString(value) {
     const trimmed = value.trim();
     return trimmed ? trimmed : undefined;
 }
+async function mapWithConcurrencyLimit(items, limit, mapper) {
+    if (items.length === 0) {
+        return [];
+    }
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const workerCount = Math.max(1, Math.min(Math.trunc(limit), items.length));
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+        while (true) {
+            // Safe in Node's single-threaded event loop because no await occurs between
+            // reading and incrementing nextIndex inside this synchronous dispatch section.
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            if (currentIndex >= items.length) {
+                return;
+            }
+            results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+        }
+    }));
+    return results;
+}
 function normalizeStrictPositiveInt(value, field) {
     if (value == null) {
         return undefined;
@@ -1208,6 +1249,7 @@ export class SourceService {
             const limit = clampLimit(input.limit, 20, searchLimitCap);
             const regexPattern = match === "regex" ? compileRegex(query) : undefined;
             const queryMode = input.queryMode ?? "auto";
+            this.metrics.recordSearchQueryMode(queryMode);
             const cursorContext = buildSearchCursorContext({
                 artifactId: artifact.artifactId,
                 query,
@@ -1227,7 +1269,6 @@ export class SourceService {
             const recordHit = (hit) => {
                 accumulator.add(hit);
             };
-            const hasSeparators = /[._$]/.test(query);
             const tokenOnlyTextIntent = intent === "text" && queryMode === "token";
             if (intent === "symbol") {
                 this.searchSymbolIntent(artifact.artifactId, query, match, scope, regexPattern, recordHit);
@@ -1256,10 +1297,6 @@ export class SourceService {
                     }
                     else {
                         this.searchTextIntentIndexed(artifact.artifactId, query, match, scope, recordHit);
-                        // F-03: queryMode=auto fallback — when indexed returns 0 hits and query has separators, retry with literal scan
-                        if (queryMode === "auto" && hasSeparators && accumulator.currentCount() === 0) {
-                            this.searchTextIntent(artifact.artifactId, query, match, scope, regexPattern, recordHit);
-                        }
                     }
                     this.metrics.recordSearchIndexedHit();
                 }
@@ -1648,8 +1685,9 @@ export class SourceService {
     }
     async traceSymbolLifecycle(input) {
         const mapping = normalizeMapping(input.mapping);
-        const { className: userClassName, methodName: userMethodName } = parseQualifiedMethodSymbol(input.symbol);
-        const descriptor = normalizeOptionalString(input.descriptor);
+        const { className: userClassName, methodName: userMethodName, inlineDescriptor } = parseQualifiedMethodSymbol(input.symbol);
+        const descriptor = normalizeOptionalString(input.descriptor)
+            ?? (looksLikeJvmMethodDescriptor(inlineDescriptor) ? normalizeOptionalString(inlineDescriptor) : undefined);
         const includeTimeline = input.includeTimeline ?? false;
         const includeSnapshots = input.includeSnapshots ?? false;
         const maxVersions = clampLimit(input.maxVersions, 120, 400);
@@ -1705,60 +1743,75 @@ export class SourceService {
             selectedVersions = selectedVersions.slice(selectedVersions.length - maxVersions);
             warnings.push(`Version scan truncated to ${maxVersions} entries. Effective fromVersion is now "${selectedVersions[0]}".`);
         }
-        const resolvedSymbolsByVersion = new Map();
-        const scanned = [];
-        for (const version of selectedVersions) {
+        const referenceVersion = selectedVersions[selectedVersions.length - 1];
+        await this.rejectLifecycleClassLikeInput({
+            symbol: input.symbol,
+            className: userClassName,
+            methodName: userMethodName,
+            mapping,
+            version: referenceVersion,
+            sourcePriority: input.sourcePriority
+        });
+        const scannedResults = await mapWithConcurrencyLimit(selectedVersions, TRACE_LIFECYCLE_MAX_CONCURRENCY, async (version) => {
+            const versionWarnings = [];
             try {
-                let resolvedSymbols = resolvedSymbolsByVersion.get(version);
-                if (!resolvedSymbols) {
-                    const [obfuscatedClassName, obfuscatedMethod] = await Promise.all([
-                        this.resolveToObfuscatedClassName(userClassName, version, mapping, input.sourcePriority, warnings),
-                        this.resolveToObfuscatedMemberName(userMethodName, userClassName, descriptor, "method", version, mapping, input.sourcePriority, warnings)
-                    ]);
-                    resolvedSymbols = {
-                        className: obfuscatedClassName,
-                        methodName: obfuscatedMethod.name,
-                        methodDescriptor: obfuscatedMethod.descriptor
-                    };
-                    resolvedSymbolsByVersion.set(version, resolvedSymbols);
-                }
-                const resolvedJar = await this.versionService.resolveVersionJar(version);
+                const [obfuscatedClassName, obfuscatedMethod, resolvedJar] = await Promise.all([
+                    this.resolveToObfuscatedClassName(userClassName, version, mapping, input.sourcePriority, versionWarnings),
+                    this.resolveToObfuscatedMemberName(userMethodName, userClassName, descriptor, "method", version, mapping, input.sourcePriority, versionWarnings),
+                    this.versionService.resolveVersionJar(version)
+                ]);
                 const signature = await this.explorerService.getSignature({
-                    fqn: resolvedSymbols.className,
+                    fqn: obfuscatedClassName,
                     jarPath: resolvedJar.jarPath,
                     access: "all",
                     includeSynthetic: true
                 });
-                const sameNameMethods = signature.methods.filter((method) => method.name === resolvedSymbols.methodName);
-                const matchesDescriptor = (resolvedSymbols.methodDescriptor ?? descriptor)
-                    ? sameNameMethods.some((method) => method.jvmDescriptor === (resolvedSymbols.methodDescriptor ?? descriptor))
+                const sameNameMethods = signature.methods.filter((method) => method.name === obfuscatedMethod.name);
+                const effectiveDescriptor = obfuscatedMethod.descriptor ?? descriptor;
+                const matchesDescriptor = effectiveDescriptor
+                    ? sameNameMethods.some((method) => method.jvmDescriptor === effectiveDescriptor)
                     : sameNameMethods.length > 0;
                 const reason = !matchesDescriptor && descriptor && sameNameMethods.length > 0 ? "descriptor-mismatch" : undefined;
-                scanned.push({
-                    version,
-                    exists: matchesDescriptor,
-                    reason,
-                    determinate: true
-                });
+                return {
+                    entry: {
+                        version,
+                        exists: matchesDescriptor,
+                        reason,
+                        determinate: true
+                    },
+                    warnings: versionWarnings
+                };
             }
             catch (caughtError) {
                 if (isAppError(caughtError) && caughtError.code === ERROR_CODES.CLASS_NOT_FOUND) {
-                    scanned.push({
+                    return {
+                        entry: {
+                            version,
+                            exists: false,
+                            reason: "class-not-found",
+                            determinate: true
+                        },
+                        warnings: versionWarnings
+                    };
+                }
+                versionWarnings.push(`Failed to evaluate ${version}: ${caughtError instanceof Error ? caughtError.message : String(caughtError)}`);
+                return {
+                    entry: {
                         version,
                         exists: false,
-                        reason: "class-not-found",
-                        determinate: true
-                    });
-                    continue;
-                }
-                scanned.push({
-                    version,
-                    exists: false,
-                    reason: "unresolved",
-                    determinate: false
-                });
-                warnings.push(`Failed to evaluate ${version}: ${caughtError instanceof Error ? caughtError.message : String(caughtError)}`);
+                        reason: "unresolved",
+                        determinate: false
+                    },
+                    warnings: versionWarnings
+                };
+            }
+            finally {
+                this.releaseLifecycleMappingGraph(version, input.sourcePriority);
             }
+        });
+        const scanned = scannedResults.map((result) => result.entry);
+        for (const result of scannedResults) {
+            warnings.push(...result.warnings);
         }
         const determinate = scanned.filter((entry) => entry.determinate);
         const present = determinate.filter((entry) => entry.exists);
@@ -2699,17 +2752,18 @@ export class SourceService {
                     path: this.resolveMixinInputPath(path, "path")
                 },
                 sourcePath: path
-            })), input);
+            })), input, []);
         }
         const resolvedInput = mode === "project"
             ? this.createProjectValidateMixinConfigInput(input)
             : input;
-        const configSources = await this.resolveMixinConfigSources(resolvedInput);
+        const { sources: configSources, warnings: configWarnings } = await this.resolveMixinConfigSources(resolvedInput);
         if (configSources.length === 0) {
-            throw createError({
-                code: ERROR_CODES.INVALID_INPUT,
-                message: "Mixin config(s) contain no mixin class entries."
-            });
+            const emptyOutput = this.buildValidateMixinOutput(mode, []);
+            return this.applyValidateMixinOutputCompaction({
+                ...emptyOutput,
+                warnings: [...new Set([...emptyOutput.warnings, ...configWarnings])]
+            }, input);
         }
         return this.validateMixinMany(mode, configSources.map((entry) => ({
             source: {
@@ -2719,7 +2773,7 @@ export class SourceService {
                 configPath: entry.configPath
             },
             sourcePath: entry.sourcePath
-        })), resolvedInput);
+        })), resolvedInput, configWarnings);
     }
     createProjectValidateMixinConfigInput(input) {
         if (input.input.mode !== "project") {
@@ -3249,9 +3303,13 @@ export class SourceService {
     }
     async resolveMixinConfigSources(input) {
         if (input.input.mode !== "config") {
-            return [];
+            return {
+                sources: [],
+                warnings: []
+            };
         }
         const results = [];
+        const warnings = [];
         for (const rawConfigPath of input.input.configPaths) {
             const resolvedConfigPath = this.resolveMixinInputPath(rawConfigPath, "configPath");
             let configJson;
@@ -3272,6 +3330,7 @@ export class SourceService {
                 ...(configJson.server ?? [])
             ];
             if (classNames.length === 0) {
+                warnings.push(`Mixin config "${resolvedConfigPath}" contains no mixin class entries.`);
                 continue;
             }
             const projectBase = input.projectPath
@@ -3306,9 +3365,12 @@ export class SourceService {
                 });
             }
         }
-        return results;
+        return {
+            sources: results,
+            warnings
+        };
     }
-    async validateMixinMany(mode, entries, input) {
+    async validateMixinMany(mode, entries, input, additionalWarnings) {
         const results = [];
         const batchWarningMode = input.warningMode ?? "aggregated";
         const { input: _discardedInput, ...sharedInput } = input;
@@ -3335,7 +3397,13 @@ export class SourceService {
                 });
             }
         }
-        return this.applyValidateMixinOutputCompaction(this.buildValidateMixinOutput(mode, results), input);
+        const output = this.buildValidateMixinOutput(mode, results);
+        return this.applyValidateMixinOutputCompaction({
+            ...output,
+            warnings: additionalWarnings.length === 0
+                ? output.warnings
+                : [...new Set([...output.warnings, ...additionalWarnings])]
+        }, input);
     }
     applyValidateMixinOutputCompaction(output, input) {
         let nextOutput = output;
@@ -3617,6 +3685,7 @@ export class SourceService {
         const candidateLimit = this.indexedCandidateLimitForMatch(match);
         const indexed = this.filesRepo.searchFileCandidates(artifactId, {
             query,
+            match,
             limit: candidateLimit,
             mode: "text"
         });
@@ -3701,13 +3770,20 @@ export class SourceService {
         }
     }
     searchTextIntent(artifactId, query, match, scope, regexPattern, onHit) {
-        const filePaths = this.loadScopedFilePaths(artifactId, scope);
         const pageSize = Math.max(1, this.config.searchScanPageSize ?? 250);
-        for (const chunk of chunkArray(filePaths, pageSize)) {
-            const rows = this.filesRepo.getFileContentsByPaths(artifactId, chunk);
+        const glob = scope?.fileGlob ? buildGlobRegex(normalizePathStyle(scope.fileGlob)) : undefined;
+        let cursor = undefined;
+        while (true) {
+            const page = this.filesRepo.listFileRows(artifactId, { limit: pageSize, cursor });
             this.metrics.recordSearchDbRoundtrip();
-            this.metrics.recordSearchRowsScanned(rows.length);
-            for (const row of rows) {
+            this.metrics.recordSearchRowsScanned(page.items.length);
+            for (const row of page.items) {
+                if (!checkPackagePrefix(row.filePath, scope?.packagePrefix)) {
+                    continue;
+                }
+                if (glob && !glob.test(row.filePath)) {
+                    continue;
+                }
                 const contentIndex = match === "regex"
                     ? matchRegexIndex(row.content, regexPattern)
                     : findContentMatchIndex(row.content, query, match);
@@ -3721,29 +3797,44 @@ export class SourceService {
                     reasonCodes: ["content_match", `text_${match}`]
                 });
             }
+            if (!page.nextCursor) {
+                break;
+            }
+            cursor = page.nextCursor;
         }
     }
     searchPathIntent(artifactId, query, match, scope, regexPattern, onHit) {
-        const filePaths = this.loadScopedFilePaths(artifactId, scope);
-        const matching = filePaths.flatMap((filePath) => {
-            const pathIndex = match === "regex"
-                ? matchRegexIndex(filePath, regexPattern)
-                : findMatchIndex(filePath, query, match);
-            if (pathIndex < 0) {
-                return [];
-            }
-            return [{ filePath, pathIndex }];
-        });
         const pageSize = Math.max(1, this.config.searchScanPageSize ?? 250);
-        for (const chunk of chunkArray(matching, pageSize)) {
-            for (const candidate of chunk) {
+        const glob = scope?.fileGlob ? buildGlobRegex(normalizePathStyle(scope.fileGlob)) : undefined;
+        let cursor = undefined;
+        while (true) {
+            const page = this.filesRepo.listFiles(artifactId, { limit: pageSize, cursor });
+            this.metrics.recordSearchDbRoundtrip();
+            this.metrics.recordSearchRowsScanned(page.items.length);
+            for (const filePath of page.items) {
+                if (!checkPackagePrefix(filePath, scope?.packagePrefix)) {
+                    continue;
+                }
+                if (glob && !glob.test(filePath)) {
+                    continue;
+                }
+                const pathIndex = match === "regex"
+                    ? matchRegexIndex(filePath, regexPattern)
+                    : findMatchIndex(filePath, query, match);
+                if (pathIndex < 0) {
+                    continue;
+                }
                 onHit({
-                    filePath: candidate.filePath,
-                    score: scorePathMatch(match, candidate.pathIndex),
+                    filePath,
+                    score: scorePathMatch(match, pathIndex),
                     matchedIn: "path",
                     reasonCodes: ["path_match", `path_${match}`]
                 });
             }
+            if (!page.nextCursor) {
+                break;
+            }
+            cursor = page.nextCursor;
         }
     }
     findSymbolHits(artifactId, query, match, scope, regexPattern) {
@@ -3806,31 +3897,6 @@ export class SourceService {
         }
         return result;
     }
-    loadScopedFilePaths(artifactId, scope) {
-        const glob = scope?.fileGlob ? buildGlobRegex(normalizePathStyle(scope.fileGlob)) : undefined;
-        const result = [];
-        let cursor = undefined;
-        const pageSize = Math.max(1, this.config.searchScanPageSize ?? 250);
-        while (true) {
-            const page = this.filesRepo.listFiles(artifactId, { limit: pageSize, cursor });
-            this.metrics.recordSearchDbRoundtrip();
-            this.metrics.recordSearchRowsScanned(page.items.length);
-            for (const filePath of page.items) {
-                if (!checkPackagePrefix(filePath, scope?.packagePrefix)) {
-                    continue;
-                }
-                if (glob && !glob.test(filePath)) {
-                    continue;
-                }
-                result.push(filePath);
-            }
-            if (!page.nextCursor) {
-                break;
-            }
-            cursor = page.nextCursor;
-        }
-        return result;
-    }
     indexedCandidateLimit() {
         return Math.min(Math.max(this.config.maxSearchHits * 5, 500), 5000);
     }
@@ -4051,6 +4117,38 @@ export class SourceService {
             details
         });
     }
+    rejectLifecycleClassLikeInput(input) {
+        if (!looksLikeClassSegment(input.methodName)) {
+            return;
+        }
+        const classLikeSymbol = `${input.className}.${input.methodName}`;
+        throw createError({
+            code: ERROR_CODES.INVALID_INPUT,
+            message: `symbol must be in the form "fully.qualified.Class.method".`,
+            details: {
+                symbol: input.symbol,
+                classLikeSymbol,
+                nextAction: "Pass lifecycle input as Class.method and use the separate descriptor field for exact overload matching.",
+                suggestedCall: input.version
+                    ? {
+                        tool: "check-symbol-exists",
+                        params: {
+                            version: input.version,
+                            kind: "class",
+                            name: classLikeSymbol,
+                            sourceMapping: input.mapping
+                        }
+                    }
+                    : undefined
+            }
+        });
+    }
+    releaseLifecycleMappingGraph(version, sourcePriority) {
+        if ("releaseGraphCacheEntry" in this.mappingService &&
+            typeof this.mappingService.releaseGraphCacheEntry === "function") {
+            this.mappingService.releaseGraphCacheEntry(version, sourcePriority);
+        }
+    }
     async resolveToObfuscatedClassName(className, version, mapping, sourcePriority, warnings) {
         return this.resolveClassNameForLookup({
             className,
@@ -4543,11 +4641,7 @@ export class SourceService {
     publishCacheMetrics() {
         this.metrics.setCacheEntries(this.cacheMetricsState.entries);
         this.metrics.setCacheTotalContentBytes(this.cacheMetricsState.totalContentBytes);
-        this.metrics.setCacheArtifactByteAccounting(this.cacheMetricsState.lru.map((row) => ({
-            artifact_id: row.artifactId,
-            content_bytes: row.totalContentBytes,
-            updated_at: row.updatedAt
-        })));
+        this.metrics.setCacheArtifactByteAccountingRef(this.cacheMetricsState.lru);
     }
 }
 //# sourceMappingURL=source-service.js.map

package/dist/storage/files-repo.d.ts

@@ -15,6 +15,7 @@ export interface ListFilesOptions {
 export interface SearchFilesOptions {
     limit: number;
     query: string;
+    match?: "exact" | "prefix" | "contains" | "regex";
     cursor?: string;
     mode?: "mixed" | "text" | "path";
     fetchLimitOverride?: number;

package/dist/storage/files-repo.js

@@ -102,6 +102,25 @@ function buildPreview(content, query) {
     const suffix = end < content.length ? "..." : "";
     return `${prefix}${content.slice(start, end)}${suffix}`.replace(/\s+/g, " ").trim();
 }
+function tokenizeIndexedQuery(query) {
+    return query.match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+function buildIndexedMatchQuery(query, match) {
+    const tokens = tokenizeIndexedQuery(query.trim());
+    if (tokens.length === 0) {
+        return query.trim();
+    }
+    // Separator-heavy queries become an order-agnostic FTS5 MATCH expression.
+    // Whitespace is implicit AND, which keeps "dispatcher.register" on the indexed
+    // path while SourceService re-checks hydrated path/content matches before
+    // returning hits. Callers can still use literal mode for exact substring scans.
+    return tokens.map((token, index) => {
+        if (match === "prefix" && index === tokens.length - 1) {
+            return `${token}*`;
+        }
+        return token;
+    }).join(" ");
+}
 export class FilesRepo {
     db;
     deleteStmt;
@@ -257,6 +276,7 @@ export class FilesRepo {
         }
         const cursor = parseSearchCursor(options.cursor);
         const likeQuery = `%${normalized}%`;
+        const ftsQuery = buildIndexedMatchQuery(normalized, options.match);
         const mode = options.mode ?? "mixed";
         // Cursor-adaptive fetch limit: when no cursor, use a generous limit;
         // with cursor + SQL pushdown, we need far fewer rows.
@@ -294,9 +314,9 @@ export class FilesRepo {
         }));
         const mergedByPath = new Map(merged.map((hit) => [hit.filePath, hit]));
         let contentRows = [];
-        if (includeContent) {
+        if (includeContent && ftsQuery) {
             try {
-                contentRows = this.searchFtsStmt.all(artifactId, normalized, fetchLimit);
+                contentRows = this.searchFtsStmt.all(artifactId, ftsQuery, fetchLimit);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
@@ -305,7 +325,7 @@ export class FilesRepo {
                 }
                 log("warn", "storage.files.fts_syntax_error", {
                     artifactId,
-                    query: normalized,
+                    query: ftsQuery,
                     message
                 });
             }
@@ -379,14 +399,18 @@ export class FilesRepo {
         if (!normalized) {
             return 0;
         }
+        const ftsQuery = buildIndexedMatchQuery(normalized, "contains");
+        if (!ftsQuery) {
+            return 0;
+        }
         try {
-            const row = this.db.prepare(`SELECT COUNT(*) AS cnt FROM files_fts WHERE artifact_id = ? AND files_fts MATCH ?`).get(artifactId, normalized);
+            const row = this.db.prepare(`SELECT COUNT(*) AS cnt FROM files_fts WHERE artifact_id = ? AND files_fts MATCH ?`).get(artifactId, ftsQuery);
             return row?.cnt ?? 0;
         }
         catch {
             log("warn", "storage.files.count_text_candidates_failed", {
                 artifactId,
-                query: normalized
+                query: ftsQuery
             });
             return 0;
         }

package/dist/tool-contract-manifest.d.ts

@@ -0,0 +1,4 @@
+export declare const TOOL_SURFACE_SECTION_IDS: readonly ["v3-entry-tools", "source-exploration", "version-comparison-symbol-tracking", "mapping-symbols", "nbt-utilities", "mod-analysis", "validation", "registry-diagnostics"];
+export type ToolSurfaceSectionId = (typeof TOOL_SURFACE_SECTION_IDS)[number];
+export type ToolSurfaceLocale = "en" | "ja";
+export declare function renderToolSurfaceSection(locale: ToolSurfaceLocale, sectionId: ToolSurfaceSectionId): string;