gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/ttsr/ttsr-manager.js

@@ -0,0 +1,380 @@
+/**
+ * Time Traveling Stream Rules (TTSR) Manager
+ *
+ * Manages rules that get injected mid-stream when their condition pattern matches
+ * the agent's output. When a match occurs, the stream is aborted, the rule is
+ * injected as a system reminder, and the request is retried.
+ *
+ * The regex hot-path is delegated to a native Rust RegexSet engine when
+ * available, testing all patterns in a single DFA pass. Falls back to
+ * per-rule JS RegExp iteration when the native module is not loaded.
+ */
+import picomatch from "picomatch";
+import { debugTime, debugCount, debugPeak } from "../gsd/debug-logger.js";
+// ── Native TTSR engine (optional) ─────────────────────────────────────
+let nativeTtsr = null;
+try {
+    // Dynamic import to avoid hard dependency — gracefully degrades to JS.
+    const native = await import("@gsd/native");
+    if (native.ttsrCompileRules && native.ttsrCheckBuffer && native.ttsrFreeRules) {
+        nativeTtsr = {
+            ttsrCompileRules: native.ttsrCompileRules,
+            ttsrCheckBuffer: native.ttsrCheckBuffer,
+            ttsrFreeRules: native.ttsrFreeRules,
+        };
+    }
+}
+catch {
+    // Native module not available — JS fallback will be used.
+}
+const DEFAULT_SETTINGS = {
+    enabled: true,
+    contextMode: "discard",
+    interruptMode: "always",
+    repeatMode: "once",
+    repeatGap: 10,
+};
+/** Cap per-stream buffer at 512KB to prevent unbounded memory growth. */
+const MAX_BUFFER_BYTES = 512 * 1024;
+/**
+ * Minimum interval (ms) between JS-fallback regex checks on the same buffer.
+ * Prevents CPU spinning when deltas arrive faster than regex evaluation (#468).
+ */
+const JS_FALLBACK_CHECK_INTERVAL_MS = 50;
+const DEFAULT_SCOPE = {
+    allowText: true,
+    allowThinking: false,
+    allowAnyTool: true,
+    toolScopes: [],
+};
+export class TtsrManager {
+    #settings;
+    #rules = new Map();
+    #injectionRecords = new Map();
+    #buffers = new Map();
+    /** Tracks last JS-fallback check time per buffer key to throttle CPU (#468). */
+    #lastJsCheckAt = new Map();
+    #messageCount = 0;
+    #nativeHandle = null;
+    #nativeDirty = false;
+    constructor(settings) {
+        this.#settings = { ...DEFAULT_SETTINGS, ...settings };
+    }
+    #canTrigger(ruleName) {
+        const record = this.#injectionRecords.get(ruleName);
+        if (!record)
+            return true;
+        if (this.#settings.repeatMode === "once")
+            return false;
+        const gap = this.#messageCount - record.lastInjectedAt;
+        return gap >= this.#settings.repeatGap;
+    }
+    #compileConditions(rule) {
+        const compiled = [];
+        for (const pattern of rule.condition ?? []) {
+            try {
+                compiled.push(new RegExp(pattern));
+            }
+            catch (err) {
+                console.warn(`[ttsr] Rule "${rule.name}": invalid regex "${pattern}" — ${err.message}`);
+            }
+        }
+        return compiled;
+    }
+    #compileGlobalPathMatchers(globs) {
+        if (!globs || globs.length === 0)
+            return undefined;
+        const matchers = globs
+            .map((g) => g.trim())
+            .filter((g) => g.length > 0)
+            .map((g) => picomatch(g));
+        return matchers.length > 0 ? matchers : undefined;
+    }
+    #parseToolScopeToken(token) {
+        const match = /^(?:(?<prefix>tool)(?::(?<tool>[a-z0-9_-]+))?|(?<bare>[a-z0-9_-]+))(?:\((?<path>[^)]+)\))?$/i.exec(token);
+        if (!match)
+            return undefined;
+        const groups = match.groups;
+        const hasToolPrefix = groups?.prefix !== undefined;
+        const toolName = (groups?.tool ?? (hasToolPrefix ? undefined : groups?.bare))?.trim().toLowerCase();
+        const pathPattern = groups?.path?.trim();
+        if (!pathPattern)
+            return { toolName };
+        return {
+            toolName,
+            pathPattern,
+            pathMatcher: picomatch(pathPattern),
+        };
+    }
+    #buildScope(rule) {
+        if (!rule.scope || rule.scope.length === 0) {
+            return {
+                allowText: DEFAULT_SCOPE.allowText,
+                allowThinking: DEFAULT_SCOPE.allowThinking,
+                allowAnyTool: DEFAULT_SCOPE.allowAnyTool,
+                toolScopes: [...DEFAULT_SCOPE.toolScopes],
+            };
+        }
+        const scope = {
+            allowText: false,
+            allowThinking: false,
+            allowAnyTool: false,
+            toolScopes: [],
+        };
+        for (const rawToken of rule.scope) {
+            const token = rawToken.trim();
+            const normalized = token.toLowerCase();
+            if (token.length === 0)
+                continue;
+            if (normalized === "text") {
+                scope.allowText = true;
+                continue;
+            }
+            if (normalized === "thinking") {
+                scope.allowThinking = true;
+                continue;
+            }
+            if (normalized === "tool" || normalized === "toolcall") {
+                scope.allowAnyTool = true;
+                continue;
+            }
+            const toolScope = this.#parseToolScopeToken(token);
+            if (!toolScope)
+                continue;
+            if (!toolScope.toolName && !toolScope.pathMatcher) {
+                scope.allowAnyTool = true;
+                continue;
+            }
+            scope.toolScopes.push(toolScope);
+        }
+        return scope;
+    }
+    #hasReachableScope(scope) {
+        return scope.allowText || scope.allowThinking || scope.allowAnyTool || scope.toolScopes.length > 0;
+    }
+    #bufferKey(context) {
+        if (context.streamKey && context.streamKey.trim().length > 0)
+            return context.streamKey;
+        if (context.source !== "tool")
+            return context.source;
+        const toolName = context.toolName?.trim().toLowerCase();
+        return toolName ? `tool:${toolName}` : "tool";
+    }
+    #normalizePath(pathValue) {
+        return pathValue.replaceAll("\\", "/");
+    }
+    #matchesGlob(matcher, filePaths) {
+        if (!filePaths || filePaths.length === 0)
+            return false;
+        for (const filePath of filePaths) {
+            const normalized = this.#normalizePath(filePath);
+            if (matcher(normalized))
+                return true;
+            const slashIndex = normalized.lastIndexOf("/");
+            const basename = slashIndex === -1 ? normalized : normalized.slice(slashIndex + 1);
+            if (basename !== normalized && matcher(basename))
+                return true;
+        }
+        return false;
+    }
+    #matchesGlobalPaths(entry, context) {
+        if (!entry.globalPathMatchers || entry.globalPathMatchers.length === 0)
+            return true;
+        for (const matcher of entry.globalPathMatchers) {
+            if (this.#matchesGlob(matcher, context.filePaths))
+                return true;
+        }
+        return false;
+    }
+    #matchesScope(entry, context) {
+        if (context.source === "text")
+            return entry.scope.allowText;
+        if (context.source === "thinking")
+            return entry.scope.allowThinking;
+        if (entry.scope.allowAnyTool)
+            return true;
+        const toolName = context.toolName?.trim().toLowerCase();
+        for (const toolScope of entry.scope.toolScopes) {
+            if (toolScope.toolName && toolScope.toolName !== toolName)
+                continue;
+            if (toolScope.pathMatcher && !this.#matchesGlob(toolScope.pathMatcher, context.filePaths))
+                continue;
+            return true;
+        }
+        return false;
+    }
+    #matchesCondition(entry, streamBuffer) {
+        for (const condition of entry.conditions) {
+            condition.lastIndex = 0;
+            if (condition.test(streamBuffer))
+                return true;
+        }
+        return false;
+    }
+    /** Compile (or recompile) the native RegexSet from all current rules. */
+    #compileNative() {
+        if (!nativeTtsr || !this.#nativeDirty)
+            return;
+        // Free previous handle if any.
+        if (this.#nativeHandle !== null) {
+            try {
+                nativeTtsr.ttsrFreeRules(this.#nativeHandle);
+            }
+            catch { /* ignore */ }
+            this.#nativeHandle = null;
+        }
+        const ruleInputs = [];
+        for (const [, entry] of this.#rules) {
+            ruleInputs.push({
+                name: entry.rule.name,
+                conditions: entry.rule.condition,
+            });
+        }
+        if (ruleInputs.length === 0) {
+            this.#nativeDirty = false;
+            return;
+        }
+        try {
+            this.#nativeHandle = nativeTtsr.ttsrCompileRules(ruleInputs);
+        }
+        catch (err) {
+            console.warn(`[ttsr] Native compilation failed, using JS fallback: ${err.message}`);
+            this.#nativeHandle = null;
+        }
+        this.#nativeDirty = false;
+    }
+    /** Add a TTSR rule to be monitored. */
+    addRule(rule) {
+        if (this.#rules.has(rule.name))
+            return false;
+        const conditions = this.#compileConditions(rule);
+        if (conditions.length === 0)
+            return false;
+        const scope = this.#buildScope(rule);
+        if (!this.#hasReachableScope(scope))
+            return false;
+        const globalPathMatchers = this.#compileGlobalPathMatchers(rule.globs);
+        this.#rules.set(rule.name, { rule, conditions, scope, globalPathMatchers });
+        this.#nativeDirty = true;
+        return true;
+    }
+    /**
+     * Add a stream chunk to its scoped buffer and return matching rules.
+     *
+     * Buffers are isolated by source/tool key so matches don't bleed across
+     * assistant prose, thinking text, and unrelated tool argument streams.
+     *
+     * When the native Rust engine is available, all regex conditions are tested
+     * in a single DFA pass via RegexSet. Scope, glob, and repeat-gate checks
+     * remain in JS as they are lightweight and context-dependent.
+     */
+    checkDelta(delta, context) {
+        const stopTimer = debugTime("ttsr-check");
+        const bufferKey = this.#bufferKey(context);
+        let nextBuffer = `${this.#buffers.get(bufferKey) ?? ""}${delta}`;
+        // Cap buffer size — keep the tail so patterns still match recent output
+        if (nextBuffer.length > MAX_BUFFER_BYTES) {
+            nextBuffer = nextBuffer.slice(-MAX_BUFFER_BYTES);
+        }
+        this.#buffers.set(bufferKey, nextBuffer);
+        debugPeak("ttsrPeakBuffer", nextBuffer.length);
+        // Lazily compile native engine if rules changed.
+        if (this.#nativeDirty)
+            this.#compileNative();
+        // ── Native path: single-pass RegexSet match ───────────────────────
+        if (nativeTtsr && this.#nativeHandle !== null) {
+            const regexMatchedNames = nativeTtsr.ttsrCheckBuffer(this.#nativeHandle, nextBuffer);
+            const regexMatchedSet = new Set(regexMatchedNames);
+            const matches = [];
+            for (const [name, entry] of this.#rules) {
+                if (!regexMatchedSet.has(name))
+                    continue;
+                if (!this.#canTrigger(name))
+                    continue;
+                if (!this.#matchesScope(entry, context))
+                    continue;
+                if (!this.#matchesGlobalPaths(entry, context))
+                    continue;
+                matches.push(entry.rule);
+            }
+            debugCount("ttsrChecks");
+            stopTimer({ bufferSize: nextBuffer.length, native: true, rulesChecked: this.#rules.size, matched: matches.map(m => m.name) });
+            return matches;
+        }
+        // ── JS fallback: per-rule regex iteration ─────────────────────────
+        // Throttle JS regex checks to prevent CPU spinning on fast token
+        // streams — regex on a growing buffer is O(rules × buffer_size) (#468).
+        const now = Date.now();
+        const lastCheck = this.#lastJsCheckAt.get(bufferKey) ?? 0;
+        if (now - lastCheck < JS_FALLBACK_CHECK_INTERVAL_MS) {
+            stopTimer({ bufferSize: nextBuffer.length, throttled: true });
+            return [];
+        }
+        this.#lastJsCheckAt.set(bufferKey, now);
+        const matches = [];
+        for (const [name, entry] of this.#rules) {
+            if (!this.#canTrigger(name))
+                continue;
+            if (!this.#matchesScope(entry, context))
+                continue;
+            if (!this.#matchesGlobalPaths(entry, context))
+                continue;
+            if (!this.#matchesCondition(entry, nextBuffer))
+                continue;
+            matches.push(entry.rule);
+        }
+        debugCount("ttsrChecks");
+        stopTimer({ bufferSize: nextBuffer.length, native: false, rulesChecked: this.#rules.size, matched: matches.map(m => m.name) });
+        return matches;
+    }
+    /** Mark rules as injected (won't trigger again until conditions allow). */
+    markInjected(rulesToMark) {
+        this.markInjectedByNames(rulesToMark.map((r) => r.name));
+    }
+    /** Mark rule names as injected. */
+    markInjectedByNames(ruleNames) {
+        for (const rawName of ruleNames) {
+            const ruleName = rawName.trim();
+            if (ruleName.length === 0)
+                continue;
+            const record = this.#injectionRecords.get(ruleName);
+            if (!record) {
+                this.#injectionRecords.set(ruleName, { lastInjectedAt: this.#messageCount });
+            }
+            else {
+                record.lastInjectedAt = this.#messageCount;
+            }
+        }
+    }
+    /** Get names of all injected rules (for persistence). */
+    getInjectedRuleNames() {
+        return Array.from(this.#injectionRecords.keys());
+    }
+    /** Restore injected state from a list of rule names. */
+    restoreInjected(ruleNames) {
+        for (const name of ruleNames) {
+            this.#injectionRecords.set(name, { lastInjectedAt: 0 });
+        }
+    }
+    /** Reset stream buffers (called on new turn). */
+    resetBuffer() {
+        this.#buffers.clear();
+        this.#lastJsCheckAt.clear();
+    }
+    /** Check if any TTSR rules are registered. */
+    hasRules() {
+        return this.#rules.size > 0;
+    }
+    /** Increment message counter (call after each turn). */
+    incrementMessageCount() {
+        this.#messageCount++;
+    }
+    /** Get current message count. */
+    getMessageCount() {
+        return this.#messageCount;
+    }
+    /** Get settings. */
+    getSettings() {
+        return this.#settings;
+    }
+}

package/dist/resources/extensions/universal-config/discovery.js

@@ -0,0 +1,94 @@
+/**
+ * Universal Config Discovery — main discovery orchestrator
+ *
+ * Runs all tool scanners in parallel and aggregates results into a
+ * unified DiscoveryResult.
+ */
+import { homedir } from "node:os";
+import { TOOLS } from "./tools.js";
+import { SCANNERS } from "./scanners.js";
+/** Inline concurrency limiter to cap parallel async operations. */
+function pLimit(concurrency) {
+    const queue = [];
+    let active = 0;
+    return (fn) => {
+        return new Promise((resolve, reject) => {
+            const run = () => {
+                active++;
+                fn().then(resolve, reject).finally(() => {
+                    active--;
+                    if (queue.length > 0)
+                        queue.shift()();
+                });
+            };
+            if (active < concurrency)
+                run();
+            else
+                queue.push(run);
+        });
+    };
+}
+/**
+ * Run universal config discovery across all supported AI coding tools.
+ *
+ * @param projectRoot - Absolute path to the project root (cwd)
+ * @param home - Home directory override (defaults to os.homedir())
+ * @returns Aggregated discovery result
+ */
+export async function discoverAllConfigs(projectRoot, home = homedir()) {
+    const start = Date.now();
+    const allWarnings = [];
+    const toolResults = [];
+    // Run scanners with bounded concurrency to avoid memory spikes
+    const limit = pLimit(5);
+    const results = await Promise.allSettled(TOOLS.map((tool) => limit(async () => {
+        const scanner = SCANNERS[tool.id];
+        if (!scanner)
+            return { tool, items: [], warnings: [`No scanner for ${tool.id}`] };
+        try {
+            const { items, warnings } = await scanner(projectRoot, home, tool);
+            return { tool, items, warnings };
+        }
+        catch (err) {
+            return {
+                tool,
+                items: [],
+                warnings: [`Scanner error for ${tool.name}: ${err instanceof Error ? err.message : String(err)}`],
+            };
+        }
+    })));
+    for (const result of results) {
+        if (result.status === "fulfilled") {
+            toolResults.push(result.value);
+            allWarnings.push(...result.value.warnings);
+        }
+        else {
+            allWarnings.push(`Scanner failed: ${result.reason}`);
+        }
+    }
+    const allItems = toolResults.flatMap((r) => r.items);
+    const mcpServers = allItems.filter((i) => i.type === "mcp-server").length;
+    const rules = allItems.filter((i) => i.type === "rule").length;
+    const contextFiles = allItems.filter((i) => i.type === "context-file").length;
+    const settings = allItems.filter((i) => i.type === "settings").length;
+    const claudeSkills = allItems.filter((i) => i.type === "claude-skill").length;
+    const claudePlugins = allItems.filter((i) => i.type === "claude-plugin").length;
+    const toolsWithConfig = toolResults.filter((r) => r.items.length > 0).length;
+    return {
+        tools: toolResults,
+        allItems,
+        summary: {
+            mcpServers,
+            rules,
+            contextFiles,
+            settings,
+            claudeSkills,
+            claudePlugins,
+            totalItems: allItems.length,
+            toolsScanned: TOOLS.length,
+            toolsWithConfig,
+        },
+        warnings: allWarnings,
+        durationMs: Date.now() - start,
+    };
+}

package/dist/resources/extensions/universal-config/format.js

@@ -0,0 +1,178 @@
+/**
+ * Universal Config Discovery — output formatting
+ *
+ * Formats DiscoveryResult into human-readable and LLM-readable output.
+ */
+/**
+ * Format discovery result as a compact text report for the LLM tool response.
+ */
+export function formatDiscoveryForTool(result) {
+    const lines = [];
+    const { summary } = result;
+    lines.push(`Universal Config Discovery — ${summary.toolsWithConfig}/${summary.toolsScanned} tools with config (${result.durationMs}ms)`);
+    lines.push("");
+    if (summary.totalItems === 0) {
+        lines.push("No configuration found from any AI coding tool.");
+        lines.push("");
+        lines.push("Scanned for: Claude Code, Cursor, Windsurf, Gemini CLI, Codex, Cline, GitHub Copilot, VS Code");
+        return lines.join("\n");
+    }
+    lines.push(`Found: ${summary.mcpServers} MCP server(s), ${summary.rules} rule(s), ${summary.contextFiles} context file(s), ${summary.settings} settings file(s), ${summary.claudeSkills} Claude skill(s), ${summary.claudePlugins} Claude plugin(s)`);
+    lines.push("");
+    for (const toolResult of result.tools) {
+        if (toolResult.items.length === 0)
+            continue;
+        lines.push(`## ${toolResult.tool.name}`);
+        const byType = groupByType(toolResult.items);
+        if (byType["mcp-server"]?.length) {
+            lines.push(`  MCP Servers (${byType["mcp-server"].length}):`);
+            for (const item of byType["mcp-server"]) {
+                if (item.type !== "mcp-server")
+                    continue;
+                const transport = item.transport ?? (item.url ? "http" : item.command ? "stdio" : "unknown");
+                const detail = item.command
+                    ? `${item.command}${item.args?.length ? ` ${item.args.join(" ")}` : ""}`
+                    : item.url ?? "no endpoint";
+                lines.push(`    - ${item.name} [${transport}] ${detail} (${item.source.level})`);
+            }
+        }
+        if (byType.rule?.length) {
+            lines.push(`  Rules (${byType.rule.length}):`);
+            for (const item of byType.rule) {
+                if (item.type !== "rule")
+                    continue;
+                const meta = [];
+                if (item.alwaysApply)
+                    meta.push("always");
+                if (item.globs?.length)
+                    meta.push(`globs: ${item.globs.join(", ")}`);
+                const suffix = meta.length ? ` [${meta.join(", ")}]` : "";
+                const preview = item.content.slice(0, 80).replace(/\n/g, " ").trim();
+                lines.push(`    - ${item.name}${suffix}: ${preview}${item.content.length > 80 ? "..." : ""}`);
+            }
+        }
+        if (byType["context-file"]?.length) {
+            lines.push(`  Context Files (${byType["context-file"].length}):`);
+            for (const item of byType["context-file"]) {
+                if (item.type !== "context-file")
+                    continue;
+                const size = item.content.length;
+                lines.push(`    - ${item.name} (${size} chars, ${item.source.level}) ${item.source.path}`);
+            }
+        }
+        if (byType.settings?.length) {
+            lines.push(`  Settings (${byType.settings.length}):`);
+            for (const item of byType.settings) {
+                if (item.type !== "settings")
+                    continue;
+                lines.push(`    - ${item.source.path} (${item.source.level})`);
+            }
+        }
+        if (byType["claude-skill"]?.length) {
+            lines.push(`  Claude Skills (${byType["claude-skill"].length}):`);
+            for (const item of byType["claude-skill"]) {
+                if (item.type !== "claude-skill")
+                    continue;
+                lines.push(`    - ${item.name} (${item.source.level}) ${item.path}`);
+            }
+        }
+        if (byType["claude-plugin"]?.length) {
+            lines.push(`  Claude Plugins (${byType["claude-plugin"].length}):`);
+            for (const item of byType["claude-plugin"]) {
+                if (item.type !== "claude-plugin")
+                    continue;
+                const label = item.packageName ? `${item.name} [${item.packageName}]` : item.name;
+                lines.push(`    - ${label} (${item.source.level}) ${item.path}`);
+            }
+        }
+        lines.push("");
+    }
+    if (result.warnings.length > 0) {
+        lines.push("Warnings:");
+        for (const w of result.warnings) {
+            lines.push(`  - ${w}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Format discovery result as a structured summary for /configs command output.
+ */
+export function formatDiscoveryForCommand(result) {
+    const lines = [];
+    const { summary } = result;
+    lines.push(`--- Universal Config Discovery ---`);
+    lines.push(`${summary.toolsWithConfig} of ${summary.toolsScanned} tools have configuration`);
+    lines.push(`${summary.totalItems} total items discovered in ${result.durationMs}ms`);
+    lines.push("");
+    if (summary.totalItems === 0) {
+        lines.push("No configuration found.");
+        return lines;
+    }
+    lines.push(`  MCP Servers: ${summary.mcpServers}`);
+    lines.push(`  Rules:       ${summary.rules}`);
+    lines.push(`  Context:     ${summary.contextFiles}`);
+    lines.push(`  Settings:    ${summary.settings}`);
+    lines.push(`  Claude skills: ${summary.claudeSkills}`);
+    lines.push(`  Claude plugins: ${summary.claudePlugins}`);
+    lines.push("");
+    for (const toolResult of result.tools) {
+        if (toolResult.items.length === 0)
+            continue;
+        const counts = countByType(toolResult.items);
+        const parts = [];
+        if (counts["mcp-server"])
+            parts.push(`${counts["mcp-server"]} MCP`);
+        if (counts.rule)
+            parts.push(`${counts.rule} rules`);
+        if (counts["context-file"])
+            parts.push(`${counts["context-file"]} context`);
+        if (counts.settings)
+            parts.push(`${counts.settings} settings`);
+        if (counts["claude-skill"])
+            parts.push(`${counts["claude-skill"]} Claude skills`);
+        if (counts["claude-plugin"])
+            parts.push(`${counts["claude-plugin"]} Claude plugins`);
+        lines.push(`  ${toolResult.tool.name}: ${parts.join(", ")}`);
+        // Show MCP server names
+        const servers = toolResult.items.filter((i) => i.type === "mcp-server");
+        for (const server of servers) {
+            if (server.type !== "mcp-server")
+                continue;
+            lines.push(`    MCP: ${server.name} (${server.source.level})`);
+        }
+        const claudeSkills = toolResult.items.filter((i) => i.type === "claude-skill");
+        for (const skill of claudeSkills) {
+            if (skill.type !== "claude-skill")
+                continue;
+            lines.push(`    Skill: ${skill.name} (${skill.source.level})`);
+        }
+        const claudePlugins = toolResult.items.filter((i) => i.type === "claude-plugin");
+        for (const plugin of claudePlugins) {
+            if (plugin.type !== "claude-plugin")
+                continue;
+            lines.push(`    Plugin: ${plugin.name} (${plugin.source.level})`);
+        }
+    }
+    if (result.warnings.length > 0) {
+        lines.push("");
+        lines.push(`${result.warnings.length} warning(s) — run discover_configs tool for details`);
+    }
+    return lines;
+}
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function groupByType(items) {
+    const groups = {};
+    for (const item of items) {
+        (groups[item.type] ??= []).push(item);
+    }
+    return groups;
+}
+function countByType(items) {
+    const counts = {};
+    for (const item of items) {
+        counts[item.type] = (counts[item.type] ?? 0) + 1;
+    }
+    return counts;
+}