flowseeker 0.1.7

package/dist/pipeline/solvePacket.js

@@ -0,0 +1,382 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSolvePacket = buildSolvePacket;
+exports.renderSolvePacketMarkdown = renderSolvePacketMarkdown;
+const fs = __importStar(require("fs/promises"));
+const fileGroups_1 = require("./fileGroups");
+const contextBlueprint_1 = require("./contextBlueprint");
+const maxPrimaryEditFiles = 7;
+const maxReadOnlyFiles = 7;
+const maxVerificationFiles = 6;
+const maxNoiseRiskFiles = 6;
+const maxSnippetChars = 850;
+const minSnippetBudgetChars = 9000;
+async function buildSolvePacket(result, config) {
+    const groups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units);
+    const coverageGroups = selectCoverageGroups(groups, result);
+    const primaryEditCandidates = coverageGroups.filter((group) => group.role === "edit_candidate" && group.slot !== "tests" && !group.contrastContext);
+    const verificationTargets = groups.filter((group) => group.slot === "tests" || group.role === "test");
+    const noiseRisk = detectNoiseRisk(groups, result);
+    const noisePaths = new Set(noiseRisk.map((group) => group.relativePath));
+    const primaryPaths = new Set(primaryEditCandidates.map((group) => group.relativePath));
+    const verificationPaths = new Set(verificationTargets.map((group) => group.relativePath));
+    const readOnlyContext = coverageGroups.filter((group) => !primaryPaths.has(group.relativePath) && !verificationPaths.has(group.relativePath) && !noisePaths.has(group.relativePath));
+    const snippetBudget = {
+        remainingChars: Math.max(minSnippetBudgetChars, config.pipeline.maxContextTokens * 4)
+    };
+    return {
+        userTask: result.task,
+        problemHypothesis: buildHypothesis(result, groups),
+        candidateFlow: buildCandidateFlow(coverageGroups, result),
+        primaryEditCandidates: await toPacketFiles(primaryEditCandidates.slice(0, Math.min(maxPrimaryEditFiles, config.pipeline.maxCandidates)), snippetBudget, "primary"),
+        readOnlyContext: await toPacketFiles(readOnlyContext.slice(0, Math.min(maxReadOnlyFiles, config.pipeline.maxCandidates)), snippetBudget, "context"),
+        verificationTargets: await toPacketFiles(verificationTargets.slice(0, Math.min(maxVerificationFiles, config.pipeline.maxCandidates)), snippetBudget, "verification"),
+        noiseRisk: await toPacketFiles(noiseRisk.slice(0, Math.min(maxNoiseRiskFiles, config.pipeline.maxCandidates)), snippetBudget, "noise"),
+        missingLinks: detectMissingLinks(groups, result),
+        agentInstructions: defaultAgentInstructions(result)
+    };
+}
+function renderSolvePacketMarkdown(packet) {
+    const lines = [
+        "# FlowSeeker Solve Packet",
+        "",
+        "## Important Note For AI",
+        "FlowSeeker evidence is candidate context, not guaranteed truth.",
+        "Validate relevance before editing.",
+        "Drop irrelevant files.",
+        "Treat contrast/noise-risk files as read-only comparison unless you can justify editing them.",
+        "Check Missing Links before making conclusions.",
+        "Do not edit outside the approved scope unless you explain why and ask for scope expansion.",
+        "If required flow context is missing, say what is missing instead of guessing.",
+        "",
+        "## User Task",
+        packet.userTask,
+        "",
+        "## Problem Hypothesis",
+        packet.problemHypothesis
+    ];
+    if (packet.candidateFlow.length > 0) {
+        lines.push("", "## Candidate Flow Coverage");
+        for (const step of packet.candidateFlow) {
+            lines.push(`### ${sectionLabel(step.section)}`, ...step.files.map((file) => `- ${file}`), "");
+        }
+    }
+    lines.push("## Primary Edit Candidates", ...renderPacketFiles(packet.primaryEditCandidates));
+    lines.push("## Read-Only Context", ...renderPacketFiles(packet.readOnlyContext));
+    lines.push("## Tests / Verification", ...renderPacketFiles(packet.verificationTargets));
+    if (packet.noiseRisk.length > 0) {
+        lines.push("## Noise Risk", ...renderPacketFiles(packet.noiseRisk));
+    }
+    if (packet.missingLinks.length > 0) {
+        lines.push("## Missing Links", ...packet.missingLinks.map((link) => `- ${link}`), "");
+    }
+    lines.push("## Agent Instructions", ...packet.agentInstructions.map((instruction, index) => `${index + 1}. ${instruction}`), "");
+    return lines.join("\n");
+}
+function buildHypothesis(result, groups) {
+    const profile = result.profile;
+    const topGroup = groups[0];
+    const topFile = topGroup?.relativePath ?? "unknown";
+    const required = profile.blueprint.requiredSlots.map(contextBlueprint_1.contextSlotLabel).join(", ");
+    const conceptPhrase = profile.concepts.length > 0 ? ` involving ${profile.concepts.slice(0, 5).join(", ")}` : "";
+    return `This is ${taskShapeArticle(profile.taskShape)} ${profile.taskShape} task${conceptPhrase}. FlowSeeker will validate the task through required context slots: ${required || "general code context"}. The strongest current evidence points to ${topFile}, but the AI must verify slot coverage before deciding what to edit.`;
+}
+function taskShapeArticle(shape) {
+    return /^[aeiou]/i.test(shape) ? "an" : "a";
+}
+function selectCoverageGroups(groups, result) {
+    const selected = new Map();
+    const maxGroups = 18;
+    const add = (group) => {
+        if (!group || selected.has(group.relativePath) || selected.size >= maxGroups) {
+            return;
+        }
+        selected.set(group.relativePath, group);
+    };
+    for (const group of groups.slice(0, 8)) {
+        add(group);
+    }
+    for (const slot of result.profile.blueprint.requiredSlots) {
+        add(bestGroupForSlot(groups, slot, selected));
+    }
+    for (const slot of result.profile.blueprint.optionalSlots) {
+        add(bestGroupForSlot(groups, slot, selected));
+        if (selected.size >= 13) {
+            break;
+        }
+    }
+    for (const group of groups) {
+        add(group);
+    }
+    return Array.from(selected.values());
+}
+function bestGroupForSlot(groups, slot, selected) {
+    return groups.find((group) => group.slot === slot && !selected.has(group.relativePath));
+}
+function buildCandidateFlow(groups, result) {
+    const flow = [];
+    const orderedSlots = (0, contextBlueprint_1.sortSlots)([...result.profile.blueprint.requiredSlots, ...result.profile.blueprint.optionalSlots, "unknown"]);
+    for (const slot of orderedSlots) {
+        const files = groups.filter((group) => group.slot === slot).map((group) => formatFlowFile(group, result));
+        if (files.length > 0) {
+            flow.push({
+                section: slot,
+                label: sectionLabel(slot),
+                files: files.slice(0, 4)
+            });
+        }
+    }
+    return flow;
+}
+function formatFlowFile(group, result) {
+    const required = (0, contextBlueprint_1.isRequiredSlot)(result.profile, group.slot) ? "required-slot" : "optional";
+    return `${group.relativePath} [${group.role}; ${required}; score ${group.score.toFixed(1)}]`;
+}
+function renderPacketFiles(files) {
+    if (files.length === 0) {
+        return ["- None identified.", ""];
+    }
+    return files.flatMap((file) => [
+        `- ${file.relativePath}`,
+        `  Slot: ${file.slot ? (0, contextBlueprint_1.contextSlotLabel)(file.slot) : "Unknown"}; Role: ${file.role}; Kind: ${file.kind}; Score: ${file.score.toFixed(1)}; Tier: ${file.tier}`,
+        ...(file.contextMode ? [`  Context: ${contextModeLabel(file.contextMode)}${file.contextRange ? `, lines ${file.contextRange.startLine}-${file.contextRange.endLine}` : ""}`] : []),
+        ...(file.reasons.length > 0 ? [`  Reasons: ${file.reasons.join("; ")}`] : []),
+        ...(file.snippet ? ["", "```", file.snippet, "```"] : []),
+        ""
+    ]);
+}
+function sectionLabel(section) {
+    return (0, contextBlueprint_1.contextSlotLabel)(section);
+}
+async function toPacketFiles(groups, budget, purpose) {
+    const files = [];
+    for (const [index, group] of groups.entries()) {
+        const snippetContext = await buildSnippetContext(group, budget, maxCharsForPurpose(purpose, index));
+        files.push({
+            relativePath: group.relativePath,
+            role: group.role,
+            kind: group.kinds[0] ?? "code_region",
+            slot: group.slot,
+            contextMode: snippetContext.mode,
+            contextRange: snippetContext.range,
+            score: group.score,
+            confidence: group.confidence,
+            tier: group.tier,
+            reasons: group.reasons.slice(0, 5),
+            snippet: snippetContext.snippet
+        });
+    }
+    return files;
+}
+function compactSnippet(snippet) {
+    if (!snippet) {
+        return undefined;
+    }
+    const trimmed = snippet.trim();
+    if (trimmed.length <= maxSnippetChars) {
+        return trimmed;
+    }
+    return `${trimmed.slice(0, maxSnippetChars)}\n... [FlowSeeker truncated snippet for token budget]`;
+}
+async function buildSnippetContext(group, budget, preferredMaxChars) {
+    const fallbackSnippet = compactEvidenceSnippets(group);
+    if (budget.remainingChars <= 0) {
+        return { snippet: fallbackSnippet, mode: fallbackSnippet ? "evidence_snippets" : undefined };
+    }
+    const maxChars = Math.max(maxSnippetChars, Math.min(preferredMaxChars, budget.remainingChars));
+    const fileContext = await readExpandedFileContext(group, maxChars);
+    if (fileContext.snippet) {
+        budget.remainingChars -= fileContext.snippet.length;
+        return fileContext;
+    }
+    if (fallbackSnippet) {
+        const snippet = truncateToBudget(fallbackSnippet, maxChars);
+        budget.remainingChars -= snippet.length;
+        return { snippet, mode: "evidence_snippets" };
+    }
+    return {};
+}
+async function readExpandedFileContext(group, maxChars) {
+    try {
+        const content = await fs.readFile(group.file, "utf8");
+        if (!content.trim() || content.includes("\u0000")) {
+            return {};
+        }
+        if (content.length <= maxChars) {
+            const lines = content.split(/\r?\n/);
+            return {
+                snippet: content.trim(),
+                mode: "full_file",
+                range: { startLine: 1, endLine: lines.length }
+            };
+        }
+        const range = expandedRange(group, content);
+        if (!range) {
+            return {
+                snippet: truncateToBudget(content.trim(), maxChars),
+                mode: "expanded_range",
+                range: { startLine: 1, endLine: Math.max(1, content.slice(0, maxChars).split(/\r?\n/).length) }
+            };
+        }
+        const lines = content.split(/\r?\n/);
+        const selected = lines.slice(range.startLine - 1, range.endLine).join("\n").trim();
+        return {
+            snippet: truncateToBudget(selected, maxChars),
+            mode: "expanded_range",
+            range
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function expandedRange(group, content) {
+    const lines = content.split(/\r?\n/);
+    const ranges = group.ranges.filter((range) => range.startLine > 0 && range.endLine >= range.startLine);
+    if (ranges.length === 0) {
+        return undefined;
+    }
+    const firstStart = Math.min(...ranges.map((range) => range.startLine));
+    const lastEnd = Math.max(...ranges.map((range) => range.endLine));
+    const span = Math.max(1, lastEnd - firstStart + 1);
+    const padding = span <= 3 ? 40 : span <= 30 ? 25 : 12;
+    return {
+        startLine: Math.max(1, firstStart - padding),
+        endLine: Math.min(lines.length, lastEnd + padding)
+    };
+}
+function compactEvidenceSnippets(group) {
+    const snippets = group.units
+        .map((unit) => unit.snippet?.trim())
+        .filter((snippet) => Boolean(snippet))
+        .slice(0, 3);
+    if (snippets.length === 0) {
+        return undefined;
+    }
+    return compactSnippet(snippets.join("\n\n--- related evidence ---\n\n"));
+}
+function truncateToBudget(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    return `${text.slice(0, Math.max(0, maxChars - 60)).trimEnd()}\n... [FlowSeeker truncated expanded context for token budget]`;
+}
+function maxCharsForPurpose(purpose, index) {
+    if (purpose === "primary") {
+        return index < 3 ? 3200 : 1800;
+    }
+    if (purpose === "verification") {
+        return 1600;
+    }
+    if (purpose === "noise") {
+        return 700;
+    }
+    return 1400;
+}
+function contextModeLabel(mode) {
+    if (mode === "full_file") {
+        return "full file";
+    }
+    if (mode === "expanded_range") {
+        return "expanded relevant range";
+    }
+    return "evidence snippets";
+}
+function detectNoiseRisk(groups, result) {
+    const neededSlots = new Set((0, contextBlueprint_1.allContextSlots)(result.profile.blueprint));
+    return groups.filter((group) => isNoiseGroup(group, neededSlots)).slice(0, maxNoiseRiskFiles);
+}
+function isNoiseGroup(group, neededSlots) {
+    const normalized = group.relativePath.replace(/\\/g, "/").toLowerCase();
+    if (group.contrastContext) {
+        return true;
+    }
+    if (/\b(i18n|locale|locales|translation|translations|messages|message|dictionary|dictionaries|guidance|readiness|privacy|terms|legal|static|public|assets|vendor|node_modules)\b/.test(normalized)) {
+        return true;
+    }
+    if (/\b(fixture|fixtures|mock|mocks|seed|seeds|smoke|e2e|snapshot)\b/.test(normalized) && group.slot !== "tests") {
+        return true;
+    }
+    if ((group.slot === "side_effect" || group.slot === "ui" || group.slot === "docs") && !neededSlots.has(group.slot) && group.score < 70) {
+        return true;
+    }
+    return false;
+}
+function detectMissingLinks(groups, result) {
+    const missing = [];
+    const foundSlots = new Set(groups.map((group) => group.slot));
+    for (const slot of result.profile.blueprint.requiredSlots) {
+        if (!foundSlots.has(slot)) {
+            missing.push(`No ${(0, contextBlueprint_1.contextSlotLabel)(slot)} file was identified for this ${result.profile.taskShape} task.`);
+        }
+    }
+    if (isEditIntendedTask(result) && !groups.some((group) => group.role === "edit_candidate")) {
+        missing.push("No edit_candidate files were ranked with sufficient confidence. Broaden the search or relax minConfidence.");
+    }
+    if (result.stats.stoppedEarly) {
+        missing.push(`Scan stopped early: ${result.stats.stopReason ?? "budget limit reached"}. Treat coverage as partial.`);
+    }
+    return missing;
+}
+function isEditIntendedTask(result) {
+    return !["investigation", "unknown"].includes(result.profile.taskShape);
+}
+function defaultAgentInstructions(result) {
+    if (!isEditIntendedTask(result)) {
+        return [
+            "This is a read-only investigation/explanation task. Do not propose code edits unless the user explicitly asks for changes.",
+            "Explain the current behavior from the retrieved context. Separate confirmed facts from reasonable inferences.",
+            "Use the candidate flow to describe how data moves through entry, UI, domain, data, config, and side-effect files.",
+            "Drop irrelevant evidence files. Mention only files that materially explain the behavior.",
+            "If context is partial, state the confidence level and the single most useful file or endpoint to inspect next.",
+            "Do not ask for broader scope when the current packet is enough to answer the user's question.",
+            "End with concise risks or unknowns only when they affect the explanation."
+        ];
+    }
+    return [
+        "First decide whether the packet has enough required context slots to answer safely.",
+        "Validate the candidate flow before editing. Confirm each file's relevance by reading its content.",
+        "Drop irrelevant evidence files. Do not reference or edit files that are noise risk unless they are actually needed.",
+        "Treat contrast/noise-risk files as behavior-to-avoid or read-only comparison unless editing them is clearly required.",
+        "Produce a reviewable plan first: what changes, why, and in which files.",
+        "Only after user approval, generate the smallest coherent set of edits within the approved scope.",
+        "If a required slot is missing, state exactly what is missing and ask for a broader search before guessing.",
+        "Update or suggest tests when the behavior of a tested unit changes.",
+        "Run focused checks (lint, typecheck, unit tests) after applying edits.",
+        "Summarize changed files, remaining risk, and verification gaps when done."
+    ];
+}
+//# sourceMappingURL=solvePacket.js.map

package/dist/pipeline/subsystem.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferSubsystem = inferSubsystem;
+exports.inferSubsystemTerms = inferSubsystemTerms;
+exports.inferTaskSubsystemTerms = inferTaskSubsystemTerms;
+exports.subsystemAlignmentScore = subsystemAlignmentScore;
+exports.primarySubsystemFromUnits = primarySubsystemFromUnits;
+const text_1 = require("../utils/text");
+const genericSegments = new Set([
+    "api",
+    "app",
+    "apps",
+    "backend",
+    "bin",
+    "cmd",
+    "common",
+    "component",
+    "components",
+    "config",
+    "configs",
+    "constants",
+    "controller",
+    "controllers",
+    "core",
+    "data",
+    "database",
+    "db",
+    "domain",
+    "dto",
+    "dtos",
+    "entity",
+    "entities",
+    "events",
+    "frontend",
+    "handler",
+    "handlers",
+    "helper",
+    "helpers",
+    "hook",
+    "hooks",
+    "infra",
+    "infrastructure",
+    "internal",
+    "job",
+    "jobs",
+    "lib",
+    "libs",
+    "mail",
+    "middleware",
+    "migration",
+    "migrations",
+    "model",
+    "models",
+    "module",
+    "modules",
+    "page",
+    "pages",
+    "package",
+    "packages",
+    "policy",
+    "policies",
+    "public",
+    "queue",
+    "queues",
+    "repository",
+    "repositories",
+    "request",
+    "requests",
+    "resource",
+    "resources",
+    "route",
+    "routes",
+    "schema",
+    "schemas",
+    "screen",
+    "screens",
+    "server",
+    "service",
+    "services",
+    "shared",
+    "src",
+    "store",
+    "stores",
+    "template",
+    "templates",
+    "test",
+    "tests",
+    "type",
+    "types",
+    "ui",
+    "util",
+    "utils",
+    "validator",
+    "validators",
+    "view",
+    "views",
+    "web",
+    "worker",
+    "workers"
+]);
+const lowSignalTaskTerms = new Set([
+    "add",
+    "all",
+    "auto",
+    "bug",
+    "cache",
+    "change",
+    "check",
+    "code",
+    "config",
+    "create",
+    "data",
+    "debug",
+    "delete",
+    "display",
+    "error",
+    "file",
+    "files",
+    "find",
+    "fix",
+    "flow",
+    "form",
+    "handle",
+    "handler",
+    "input",
+    "issue",
+    "list",
+    "logic",
+    "new",
+    "page",
+    "query",
+    "request",
+    "review",
+    "route",
+    "schema",
+    "screen",
+    "service",
+    "show",
+    "status",
+    "system",
+    "table",
+    "test",
+    "type",
+    "update",
+    "user",
+    "valid",
+    "validate",
+    "view"
+]);
+const roleSuffixes = [
+    "api",
+    "command",
+    "component",
+    "config",
+    "configuration",
+    "controller",
+    "dto",
+    "entity",
+    "event",
+    "form",
+    "handler",
+    "helper",
+    "hook",
+    "job",
+    "listener",
+    "middleware",
+    "model",
+    "page",
+    "policy",
+    "provider",
+    "query",
+    "repository",
+    "request",
+    "resolver",
+    "route",
+    "schema",
+    "service",
+    "store",
+    "task",
+    "template",
+    "type",
+    "validator",
+    "view",
+    "worker"
+];
+function inferSubsystem(relativePath, symbolNames = []) {
+    return inferSubsystemTerms(relativePath, symbolNames)[0];
+}
+function inferSubsystemTerms(relativePath, symbolNames = []) {
+    const normalizedPath = relativePath.replace(/\\/g, "/");
+    const pathTerms = pathSubsystemTerms(normalizedPath);
+    const symbolTerms = symbolNames.flatMap((symbol) => symbolSubsystemTerms(symbol));
+    return (0, text_1.uniq)([...pathTerms, ...symbolTerms])
+        .map(text_1.normalizeText)
+        .filter((term) => isUsefulSubsystemTerm(term))
+        .slice(0, 6);
+}
+function inferTaskSubsystemTerms(profile) {
+    const sourceTerms = [...profile.entities, ...profile.concepts, ...profile.keywords];
+    return (0, text_1.uniq)(sourceTerms.flatMap(text_1.splitIdentifier))
+        .map(text_1.normalizeText)
+        .filter((term) => term.length > 2 && !genericSegments.has(term) && !lowSignalTaskTerms.has(term))
+        .slice(0, 10);
+}
+function subsystemAlignmentScore(unit, profile) {
+    const taskTerms = inferTaskSubsystemTerms(profile);
+    if (taskTerms.length === 0) {
+        return 0;
+    }
+    const unitTerms = unit.subsystemTerms?.length
+        ? unit.subsystemTerms
+        : inferSubsystemTerms(unit.relativePath, unit.symbols ?? []);
+    if (unitTerms.length === 0) {
+        return 0;
+    }
+    const matches = unitTerms.filter((term) => taskTerms.some((taskTerm) => term === taskTerm || term.includes(taskTerm) || taskTerm.includes(term)));
+    if (matches.length > 0) {
+        return 4 + Math.min(10, matches.length * 4);
+    }
+    return 0;
+}
+function primarySubsystemFromUnits(units) {
+    const counts = new Map();
+    for (const unit of units) {
+        if (!unit.subsystem || unit.contrastContext) {
+            continue;
+        }
+        counts.set(unit.subsystem, (counts.get(unit.subsystem) ?? 0) + Math.max(1, Math.round(unit.score / 50)));
+    }
+    return Array.from(counts.entries()).sort((left, right) => right[1] - left[1])[0]?.[0];
+}
+function pathSubsystemTerms(relativePath) {
+    const segments = relativePath
+        .split("/")
+        .map((segment) => segment.replace(/\.[^.]+$/, ""))
+        .flatMap(text_1.splitIdentifier)
+        .map(text_1.normalizeText)
+        .filter(Boolean);
+    const basename = relativePath.split("/").pop()?.replace(/\.[^.]+$/, "") ?? "";
+    const basenameTerms = trimRoleSuffixes((0, text_1.splitIdentifier)(basename).map(text_1.normalizeText));
+    const segmentTerms = segments.filter((segment) => isUsefulSubsystemTerm(segment));
+    return (0, text_1.uniq)([...basenameTerms, ...segmentTerms]);
+}
+function symbolSubsystemTerms(symbolName) {
+    return trimRoleSuffixes((0, text_1.splitIdentifier)(symbolName).map(text_1.normalizeText)).filter(isUsefulSubsystemTerm);
+}
+function trimRoleSuffixes(terms) {
+    const trimmed = [...terms];
+    while (trimmed.length > 1 && roleSuffixes.includes(trimmed[trimmed.length - 1])) {
+        trimmed.pop();
+    }
+    return trimmed;
+}
+function isUsefulSubsystemTerm(term) {
+    return term.length > 2 && !genericSegments.has(term) && !lowSignalTaskTerms.has(term) && !/^\d+$/.test(term);
+}
+//# sourceMappingURL=subsystem.js.map