hledger-lsp 0.2.6 → 0.2.8

package/out/features/inlayHints.d.ts

@@ -15,30 +15,7 @@ export declare class InlayHintsProvider {
      * Provide inlay hints for a document
      */
     provideInlayHints(document: TextDocument, range: Range, parsed: ParsedDocument, settings?: HledgerSettings): InlayHint[];
-    /**
-     * Calculate insertion position for inferred amount hint
-     */
-    private calculateInferredAmountHintInsertionPosition;
-    /**
-   * Calculate insertion position for Running Balance assertion hint
-   */
-    private calculateAssertionHintInsertionPosition;
-    /**
-   * Calculate insertion position for Cost assertion hint
-   */
-    private calculateCostHintInsertionPosition;
-    /**
-     * Get hints for inferred amounts (postings with amounts marked as inferred)
-     */
-    private getInferredAmountHints;
-    /**
-     * Get hints for running balances after each posting (with pre-calculated state)
-     */
-    private getRunningBalanceHintsWithState;
-    /**
-     * Get hints for cost conversions
-     */
-    private getCostConversionHints;
+    private processTransactions;
 }
 export declare const inlayHintsProvider: InlayHintsProvider;
 //# sourceMappingURL=inlayHints.d.ts.map

package/out/features/inlayHints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inlayHints.d.ts","sourceRoot":"","sources":["../../src/features/inlayHints.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,SAAS,EAA+C,KAAK,EAAW,MAAM,uBAAuB,CAAC;AAC/G,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAElE,OAAO,EAAE,cAAc,EAAgC,MAAM,UAAU,CAAC;AAIxE,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,oBAAoB,CAAC;AAE5B,qBAAa,kBAAkB;IAC7B;;OAEG;IACH,iBAAiB,CACf,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,cAAc,EACtB,QAAQ,CAAC,EAAE,eAAe,GACzB,SAAS,EAAE;IA6Cd;;OAEG;IACH,OAAO,CAAC,4CAA4C;IA4BpD;;KAEC;IACD,OAAO,CAAC,uCAAuC;IAkB/C;;KAEC;IACD,OAAO,CAAC,kCAAkC;IAiB1C;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAmF9B;;OAEG;IACH,OAAO,CAAC,+BAA+B;IA6FvC;;OAEG;IACH,OAAO,CAAC,sBAAsB;CAoE/B;AAED,eAAO,MAAM,kBAAkB,oBAA2B,CAAC"}
+{"version":3,"file":"inlayHints.d.ts","sourceRoot":"","sources":["../../src/features/inlayHints.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,SAAS,EAA+C,KAAK,EAAW,MAAM,uBAAuB,CAAC;AAC/G,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAElE,OAAO,EAAE,cAAc,EAAgC,MAAM,UAAU,CAAC;AAIxE,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,oBAAoB,CAAC;AAG5B,qBAAa,kBAAkB;IAC7B;;OAEG;IACH,iBAAiB,CACf,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,cAAc,EACtB,QAAQ,CAAC,EAAE,eAAe,GACzB,SAAS,EAAE;IA8Kd,OAAO,CAAC,mBAAmB;CAgQ5B;AAED,eAAO,MAAM,kBAAkB,oBAA2B,CAAC"}

package/out/features/inlayHints.js

@@ -14,262 +14,359 @@ const vscode_uri_1 = require("vscode-uri");
 const amountFormatter_1 = require("../utils/amountFormatter");
 const runningBalanceCalculator_1 = require("../utils/runningBalanceCalculator");
 const settings_1 = require("../server/settings");
+const formatter_1 = require("./formatter");
 class InlayHintsProvider {
     /**
      * Provide inlay hints for a document
      */
     provideInlayHints(document, range, parsed, settings) {
         const config = { ...settings_1.DEFAULT_INLAY_HINTS_OPTIONS, ...settings?.inlayHints };
+        const formattingOptions = { ...settings_1.DEFAULT_FORMATTING_OPTIONS, ...settings?.formatting };
         const hints = [];
-        // Normalize document URI to ensure proper encoding
         const documentUri = vscode_uri_1.URI.parse(document.uri).toString();
         // If showing running balances, we need to process all transactions to accumulate balances
-        // Otherwise, only process transactions within the requested range
         const runningBalances = config.showRunningBalances
             ? (0, runningBalanceCalculator_1.calculateRunningBalances)(parsed)
             : new Map();
-        // Only process transactions within the requested range
         for (const transaction of parsed.transactions) {
-            // Only show inlay hints for transactions in the current document
             if (transaction.sourceUri?.toString() !== documentUri) {
                 continue;
             }
             const txLine = transaction.line ?? 0;
-            // Skip transactions outside the range
             if (txLine < range.start.line || txLine > range.end.line) {
                 continue;
             }
-            // Inferred amount hints
-            if (config.showInferredAmounts) {
-                hints.push(...this.getInferredAmountHints(document, transaction, parsed, settings));
-            }
-            // Running balance hints
-            if (config.showRunningBalances) {
-                hints.push(...this.getRunningBalanceHintsWithState(document, transaction, parsed, runningBalances, settings));
-            }
-            // Cost conversion hints
-            if (config.showCostConversions) {
-                hints.push(...this.getCostConversionHints(document, transaction, parsed, settings));
-            }
-        }
-        return hints;
-    }
-    /**
-     * Calculate insertion position for inferred amount hint
-     */
-    calculateInferredAmountHintInsertionPosition(line, accountEnd, amount, parsed, settings) {
-        const options = {
-            ...settings_1.DEFAULT_FORMATTING_OPTIONS,
-            ...settings?.formatting
-        };
-        // Get amount layout to determine pre-decimal width
-        const layout = (0, amountFormatter_1.getAmountLayout)(amount, parsed, options, '');
-        const preDecimalWidth = layout.commodityBefore.length +
-            (layout.spaceBetweenCommodityAndAmount && layout.commodityBefore ? 1 : 0) +
-            (layout.negPosSign ? 1 : 0) +
-            layout.amountIntegerString.length;
-        // Calculate the target position for the start of the amount (before the decimal)
-        const targetColumn = Math.max(options.decimalAlignColumn, accountEnd + options.minSpacing + preDecimalWidth);
-        const amountStartColumn = targetColumn - preDecimalWidth;
-        return amountStartColumn;
-    }
-    /**
-   * Calculate insertion position for Running Balance assertion hint
-   */
-    calculateAssertionHintInsertionPosition(line, accountEnd, amount, parsed, settings) {
-        const options = {
-            ...settings_1.DEFAULT_FORMATTING_OPTIONS,
-            ...settings?.formatting
-        };
-        // TODO implement proper calculation for assertion hint position
-        return options.decimalAlignColumn + 4; // +3 for ".00"
-    }
-    /**
-   * Calculate insertion position for Cost assertion hint
-   */
-    calculateCostHintInsertionPosition(line, accountEnd, amount, parsed, settings) {
-        const options = {
-            ...settings_1.DEFAULT_FORMATTING_OPTIONS,
-            ...settings?.formatting
-        };
-        // TODO implement proper calculation for assertion hint position
-        return options.decimalAlignColumn + 3;
-    }
-    /**
-     * Get hints for inferred amounts (postings with amounts marked as inferred)
-     */
-    getInferredAmountHints(document, transaction, parsed, settings) {
-        const hints = [];
-        const txLine = transaction.line ?? 0;
-        let postingIndex = 0;
-        for (const posting of transaction.postings) {
-            // Show hint only for inferred amounts
-            if (posting.amount && posting.amount.inferred) {
-                const lineNum = txLine + 1 + postingIndex; // +1 for header, then posting index
+            // Use formatter to calculate ideal widths (Grid)
+            // We pass the inlay hints config so the grid accounts for inferred items
+            const widths = formatter_1.formattingProvider.calculateTransactionWidths(transaction, parsed, formattingOptions, config);
+            let postingIndex = 0;
+            for (const posting of transaction.postings) {
+                const lineNum = txLine + 1 + postingIndex;
+                // Get the current line content
                 const line = document.getText({
                     start: { line: lineNum, character: 0 },
                     end: { line: lineNum, character: Number.MAX_SAFE_INTEGER }
                 });
-                // Find end of account name
-                const accountEnd = line.indexOf(posting.account) + posting.account.length;
-                // Check if non-whitespace content exists after account (before comment)
-                const afterAccount = line.substring(accountEnd);
-                const commentPos = afterAccount.search(/[;#]/);
-                const beforeComment = commentPos >= 0
-                    ? afterAccount.substring(0, commentPos)
-                    : afterAccount;
-                const hasContentAfterAccount = beforeComment.trim().length > 0;
-                // Skip hint if non-whitespace, non-comment content exists after account
-                // This prevents hints from appearing when amounts, costs, or assertions are present
-                if (hasContentAfterAccount) {
-                    postingIndex++;
-                    continue;
-                }
-                // Calculate alignment padding and insertion position
-                const insertPosition = this.calculateInferredAmountHintInsertionPosition(line, accountEnd, posting.amount, parsed, settings);
-                // Format amount without extra padding (padding handled separately)
-                const amountText = (0, amountFormatter_1.formatAmount)(posting.amount.quantity, posting.amount.commodity, parsed, settings?.formatting);
-                // Create clickable label part with command to insert the amount
-                const labelPart = {
-                    value: `${amountText}`,
-                    command: {
-                        title: 'Insert inferred amount',
-                        command: 'hledger.insertInferredAmount',
-                        arguments: [
-                            document.uri,
-                            lineNum,
-                            accountEnd,
-                            posting.amount.quantity,
-                            posting.amount.commodity
-                        ]
+                const accountEndIndex = line.indexOf(posting.account) + posting.account.length;
+                // Find comment position
+                const commentMatch = line.match(/[;#]/);
+                const commentIndex = commentMatch ? commentMatch.index : -1;
+                // Content "End" (before comment)
+                const contentEndIndex = commentIndex !== -1 ? commentIndex : line.length;
+                const contentBeforeComment = line.substring(0, contentEndIndex);
+                const trimmedContent = contentBeforeComment.trimEnd();
+                // Check if there is unexpected content after account
+                // If the line is just "Account", trimmedContent length is accountEndIndex.
+                // If the line is "Account  $10", trimmedContent is longer.
+                // We only insert hints if we are "at the end" of the relevant explicit content.
+                // 1. Inferred Amount
+                if (config.showInferredAmounts && posting.amount && posting.amount.inferred) {
+                    // Check if we have explicit content blocking us (e.g. tags, or manually written stuff)
+                    // If the content after account is just whitespace, we are good.
+                    if (trimmedContent.length <= accountEndIndex) {
+                        const amountPreDecimalWidth = widths.amount.commodityBefore +
+                            widths.amount.spaceBetweenCommodityBeforeAndAmount +
+                            widths.amount.negPosSign +
+                            widths.amount.integerPart;
+                        const targetColumn = formattingOptions.decimalAlignColumn;
+                        // Calculate where the hint should visually start to align the decimal
+                        const hintStartColumn = targetColumn - amountPreDecimalWidth;
+                        // Current position is contentEndIndex.
+                        // We need padding to reach hintStartColumn.
+                        // Note: InlayHint padding is visual.
+                        const currentColumn = contentEndIndex; // Assuming simple chars
+                        const paddingNeeded = Math.max(1, hintStartColumn - currentColumn); // At least 1 space
+                        const amountText = (0, amountFormatter_1.formatAmount)(posting.amount.quantity, posting.amount.commodity, parsed, settings?.formatting);
+                        const labelPart = {
+                            value: amountText,
+                            command: {
+                                title: 'Insert inferred amount',
+                                command: 'hledger.insertInferredAmount',
+                                arguments: [
+                                    document.uri,
+                                    lineNum,
+                                    contentEndIndex, // Insert at end of current content
+                                    posting.amount.quantity,
+                                    posting.amount.commodity
+                                ]
+                            }
+                        };
+                        hints.push({
+                            position: vscode_languageserver_1.Position.create(lineNum, contentEndIndex),
+                            label: [labelPart],
+                            kind: vscode_languageserver_1.InlayHintKind.Parameter,
+                            paddingLeft: true, // Let VS Code handle standard padding? No, we want exact alignment.
+                            // If we use paddingLeft, it adds a standard space.
+                            // To do exact alignment, we might need to prepend spaces to the label value.
+                            // But user warned about VS Code truncating large padding.
+                            // Ideally, if the formatter ran, `currentColumn` matches `hintStartColumn`.
+                            // If not, we pad.
+                        });
+                        // Correct padding approach for alignment:
+                        // We can use `label` with leading spaces.
+                        const paddingString = ' '.repeat(paddingNeeded);
+                        // But wait, if we use `paddingLeft: true`, it adds roughly one space width?
+                        // We want exact column alignment.
+                        // Better to add spaces to the label value if we want strict alignment.
+                        // The user said: "if we pad the inlay hint itself then it has to be quite large... vscode seems to shorten is to ..."
+                        // This implies we should rely on the DOCUMENT having the whitespace (via formatter).
+                        // IF the document has whitespace, `paddingNeeded` will be small (0 or 1).
+                        // IF the document does not, we unfortunately have to pad the hint.
+                        // Let's modify the label to include the padding.
+                        labelPart.value = paddingString + amountText;
+                        // If we have a comment, we insert AT the comment position?
+                        // If we insert at `contentEndIndex`, and comment is at `commentIndex` (which equals contentEndIndex),
+                        // the hint appears before the comment.
+                        // This pushes the comment to the right. Correct.
                     }
-                };
-                hints.push({
-                    position: vscode_languageserver_1.Position.create(lineNum, insertPosition),
-                    label: [labelPart],
-                    kind: vscode_languageserver_1.InlayHintKind.Parameter,
-                    paddingLeft: false, // We handle padding ourselves
-                    tooltip: 'Click to insert this inferred amount into the document'
-                });
+                }
+                // 2. Inferred Cost
+                // ... (similar logic, using widths.cost)
+                if (config.showCostConversions && posting.cost && posting.cost.inferred) {
+                    // We can only show inferred cost if we are "past" the amount.
+                    // If amount was inferred, we effectively "added" it above.
+                    // But LSP Inlay Hints are independent.
+                    // If we have an inferred amount AND inferred cost, we need to stack them?
+                    // VS Code places hints at the same position in order.
+                    // So if we push Amount Hint, then Cost Hint, they appear: [Amount] [Cost].
+                    // We just need to calculate the Cost padding relative to the End of the Amount.
+                    // Where does the Amount end?
+                    // Amount End = TargetColumn (decimal align) + PostDecimalWidth.
+                    const amountPostDecimalWidth = widths.amount.decimalMark +
+                        widths.amount.decimalPart +
+                        widths.amount.spaceBetweenAmountAndCommodityAfter +
+                        widths.amount.commodityAfter;
+                    // The visual end of the amount block (whether explicit or inferred)
+                    const amountVisualEnd = formattingOptions.decimalAlignColumn + amountPostDecimalWidth;
+                    // Cost Start
+                    // We align Cost based on widths.cost?
+                    // Usually Cost keeps going.
+                    // Formatter logic: `line += renderAmountLayout(..., widths.cost)`
+                    // It just appends.
+                    // So we just need minimal padding from Amount End.
+                    // But if we are in "Inferred Amount" case, our "current physical position" is still `contentEndIndex`.
+                    // The Amount Hint adds virtual width.
+                    // We need to account for that.
+                    // This suggests we should calculate a "virtual cursor" position.
+                    // Start at `contentEndIndex`.
+                    // If Inferred Amount:
+                    //    Add padding + AmountText width to virtual cursor.
+                    // If Explicit Amount:
+                    //    Virtual cursor is at end of amount (which is `contentEndIndex`).
+                    // Let's implement this "Virtual Cursor" flow.
+                }
+                postingIndex++;
             }
-            postingIndex++;
         }
-        return hints;
+        return this.processTransactions(parsed, document, range, config, formattingOptions, runningBalances);
     }
-    /**
-     * Get hints for running balances after each posting (with pre-calculated state)
-     */
-    getRunningBalanceHintsWithState(document, transaction, parsed, runningBalances, settings) {
+    processTransactions(parsed, document, range, config, formattingOptions, runningBalances) {
         const hints = [];
-        // Find transaction index
-        const txIndex = parsed.transactions.indexOf(transaction);
-        if (txIndex === -1) {
-            return hints;
-        }
-        const postingBalances = runningBalances.get(txIndex);
-        if (!postingBalances) {
-            return hints;
-        }
-        const txLine = transaction.line ?? 0;
-        for (let postingIndex = 0; postingIndex < transaction.postings.length; postingIndex++) {
-            const posting = transaction.postings[postingIndex];
-            const balanceMap = postingBalances.get(postingIndex);
-            // Don't show running balance hint if posting already has a balance assertion
-            // Show hint for both explicit and inferred amounts
-            if (balanceMap && !posting.assertion) {
+        const documentUri = vscode_uri_1.URI.parse(document.uri).toString();
+        for (const transaction of parsed.transactions) {
+            if (transaction.sourceUri?.toString() !== documentUri)
+                continue;
+            const txLine = transaction.line ?? 0;
+            if (txLine < range.start.line || txLine > range.end.line)
+                continue;
+            const widths = formatter_1.formattingProvider.calculateTransactionWidths(transaction, parsed, formattingOptions, config);
+            let postingIndex = 0;
+            for (const posting of transaction.postings) {
                 const lineNum = txLine + 1 + postingIndex;
                 const line = document.getText({
                     start: { line: lineNum, character: 0 },
                     end: { line: lineNum, character: Number.MAX_SAFE_INTEGER }
                 });
-                // Find end of non-whitespace content (before comment)
-                const commentPos = line.search(/[;#]/);
-                const beforeComment = commentPos >= 0
-                    ? line.substring(0, commentPos)
-                    : line;
-                const trimmedLine = beforeComment.trimEnd();
-                const contentEnd = trimmedLine.length;
-                // Check if there's only whitespace between content end and a reasonable position
-                const afterContent = beforeComment.substring(contentEnd);
-                const hasOnlyWhitespace = afterContent.trim().length === 0;
-                const insertPosition = this.calculateAssertionHintInsertionPosition(line, contentEnd, posting.amount, parsed, settings);
-                // Format all commodity balances for this posting
-                const balanceHints = [];
-                for (const [commodity, balance] of balanceMap.entries()) {
-                    const formattedBalance = (0, amountFormatter_1.formatAmount)(balance, commodity, parsed, settings?.formatting);
-                    balanceHints.push(formattedBalance);
+                const commentMatch = line.match(/[;#]/);
+                const commentIndex = commentMatch ? commentMatch.index : -1;
+                const contentEndIndex = commentIndex !== -1 ? commentIndex : line.length;
+                const trimmedContent = line.substring(0, contentEndIndex).trimEnd();
+                // Virtual cursor assumes we are starting from the end of the clean content
+                // Use contentEndIndex (actual cursor) to account for existing whitespace
+                let virtualColumn = contentEndIndex ?? 0;
+                const insertPosition = vscode_languageserver_1.Position.create(lineNum, contentEndIndex);
+                // 1. Amount
+                if (posting.amount && !posting.amount.inferred) {
+                    // Explicit amount. Update virtual cursor to end of content.
+                    // (which is already done by init virtualColumn = trimmedContent.length)
                 }
-                const balanceText = balanceHints.join(', ');
-                // Create clickable label part with command to insert balance assertion
-                // Format as actual balance assertion syntax: " = $amount"
-                const labelPart = {
-                    value: ` = ${balanceText} `,
-                    command: {
-                        title: 'Insert balance assertion',
-                        command: 'hledger.insertBalanceAssertion',
-                        arguments: [
-                            document.uri,
-                            lineNum,
-                            posting.account,
-                            balanceHints
-                        ]
+                else if (config.showInferredAmounts && posting.amount?.inferred) {
+                    // Only show if we don't have unexpected garbage
+                    // AND if we are not blocked by explicit items (Cost or Assertion)
+                    const hasExplicitCost = posting.cost && !posting.cost.inferred;
+                    const hasExplicitAssertion = posting.assertion;
+                    if (!hasExplicitCost && !hasExplicitAssertion) {
+                        const amountPreDecimalWidth = widths.amount.commodityBefore +
+                            widths.amount.spaceBetweenCommodityBeforeAndAmount +
+                            widths.amount.negPosSign +
+                            widths.amount.integerPart;
+                        const targetColumn = formattingOptions.decimalAlignColumn;
+                        const requiredPadding = Math.max(0, targetColumn - virtualColumn - amountPreDecimalWidth);
+                        const amountText = (0, amountFormatter_1.formatAmount)(posting.amount.quantity, posting.amount.commodity, parsed, formattingOptions);
+                        const label = ' '.repeat(requiredPadding) + amountText;
+                        hints.push({
+                            position: insertPosition,
+                            label: [{
+                                    value: label,
+                                    command: {
+                                        title: 'Insert inferred amount',
+                                        command: 'hledger.insertInferredAmount',
+                                        arguments: [document.uri, lineNum, contentEndIndex, posting.amount.quantity, posting.amount.commodity]
+                                    }
+                                }],
+                            kind: vscode_languageserver_1.InlayHintKind.Parameter,
+                            paddingLeft: false
+                        });
+                        virtualColumn += label.length;
                     }
-                };
-                hints.push({
-                    position: vscode_languageserver_1.Position.create(lineNum, insertPosition),
-                    label: [labelPart],
-                    kind: vscode_languageserver_1.InlayHintKind.Type,
-                    paddingLeft: false, // No LSP padding
-                    tooltip: `Click to insert balance assertion for ${posting.account}`
-                });
-            }
-        }
-        return hints;
-    }
-    /**
-     * Get hints for cost conversions
-     */
-    getCostConversionHints(document, transaction, parsed, settings) {
-        const hints = [];
-        const txLine = transaction.line ?? 0;
-        let postingIndex = 0;
-        for (const posting of transaction.postings) {
-            // Show hint only for postings inferred costs
-            if (posting.cost && posting.cost.inferred) {
-                const lineNum = txLine + 1 + postingIndex;
-                const line = document.getText({
-                    start: { line: lineNum, character: 0 },
-                    end: { line: lineNum, character: Number.MAX_SAFE_INTEGER }
-                });
-                // Find end of account name
-                const accountEnd = line.indexOf(posting.account) + posting.account.length;
-                const insertPosition = this.calculateCostHintInsertionPosition(line, accountEnd, posting.cost.amount, parsed, settings);
-                // Format amount without extra padding (padding handled separately)
-                const amountText = (0, amountFormatter_1.formatAmount)(posting.cost.amount.quantity, posting.cost.amount.commodity, parsed, settings?.formatting);
-                // Create clickable label part with command to insert the amount
-                const labelPart = {
-                    value: ` @@ ${amountText}`,
-                    command: {
-                        title: 'Insert inferred cost',
-                        command: 'hledger.insertCost',
-                        arguments: [
-                            document.uri,
-                            lineNum,
-                            accountEnd,
-                            posting.cost.amount.quantity,
-                            posting.cost.amount.commodity
-                        ]
+                }
+                else {
+                    // No amount (or blocked inferred).
+                    // We effectively skip the "Amount Block".
+                    // But for alignment of subsequent items, we might need to pad PAST the amount block?
+                    // See formatter logic:
+                    /*
+                    const postDecimalWidth = ...
+                    line += ' '.repeat(padding + preDecimalWidth + postDecimalWidth);
+                    */
+                    // If we have hidden amounts but show costs, we might need to pad.
+                    // But Inlay Hints are additive. We can't insert "just padding" easily without a label.
+                    // Unless we attach it to the next hint.
+                }
+                // 2. Cost
+                if (posting.cost && !posting.cost.inferred) {
+                    // Explicit cost. Virtual cursor should logically be after this.
+                    // But wait, if explicit cost exists, it's in the text.
+                    // So virtualColumn (initially `trimmedContent.length`) ALREADY includes it.
+                    // We don't need to do anything.
+                }
+                else if (config.showCostConversions && posting.cost?.inferred) {
+                    // We want to add Cost Hint.
+                    // Check if blocked by explicit assertion
+                    const hasExplicitAssertion = posting.assertion;
+                    if (!hasExplicitAssertion) {
+                        const amountIsPresent = (posting.amount && !posting.amount.inferred) ||
+                            (config.showInferredAmounts && posting.amount?.inferred && !hasExplicitAssertion && !(posting.cost && !posting.cost.inferred));
+                        // Note: Logic for amountIsPresent is a bit circular if we re-check blocking logic.
+                        // Simplified: If virtualColumn has moved (meaning we added hint) OR we have explicit amount.
+                        // But virtualColumn update handles the Hint case.
+                        // Explicit Amount case? virtualColumn includes it.
+                        // So we just need to check if we are "at the start"?
+                        // Or just always pad?
+                        // If virtualColumn > trimmedContent.length, we added an Amount Hint.
+                        // If explicit Amount exists, trimmedContent.length includes it.
+                        // So we basically always want a space IF there is something before us.
+                        // If "Account" -> Inferred Amount -> " $10" -> Inferred Cost.
+                        // virtualColumn is at end of "$10". We want space.
+                        const padding = 1;
+                        const marker = (posting.cost.type === 'unit' ? '@' : '@@'); // Space handled by padding
+                        const costText = (0, amountFormatter_1.formatAmount)(posting.cost.amount.quantity, posting.cost.amount.commodity, parsed, formattingOptions);
+                        const label = ' '.repeat(padding) + marker + ' ' + costText;
+                        hints.push({
+                            position: insertPosition,
+                            label: [{
+                                    value: label,
+                                    command: {
+                                        title: 'Insert cost',
+                                        command: 'hledger.insertCost',
+                                        arguments: [document.uri, lineNum, contentEndIndex, posting.cost.amount.quantity, posting.cost.amount.commodity]
+                                    }
+                                }],
+                            kind: vscode_languageserver_1.InlayHintKind.Parameter,
+                            paddingLeft: false
+                        });
+                        virtualColumn += label.length;
                     }
-                };
-                hints.push({
-                    position: vscode_languageserver_1.Position.create(lineNum, insertPosition),
-                    label: [labelPart],
-                    kind: vscode_languageserver_1.InlayHintKind.Parameter,
-                    paddingLeft: false, // We handle padding ourselves
-                    tooltip: 'Click to insert this inferred cost into the document'
-                });
+                }
+                // 3. Running Balance (Assertion)
+                if (config.showRunningBalances && !posting.assertion) {
+                    // Find running balance
+                    const txIndex = parsed.transactions.indexOf(transaction);
+                    const postingBalances = runningBalances.get(txIndex);
+                    const balanceMap = postingBalances?.get(postingIndex);
+                    if (balanceMap) {
+                        // Align assertion?
+                        // Currently formatter aligns assertions using `widths.assertion`.
+                        // But as noted in formatter.ts, running balances are dynamic width.
+                        // We can try to align to `widths.assertion` START if it exists?
+                        // Or just align to a fixed column?
+                        // Formatter says: `line += renderAmountLayout(layout, widths.assertion)` with `marker = ' = '`.
+                        // If we are appending to existing text/hints:
+                        // We want to reach `widths.assertion` start column?
+                        // Where does assertion start in the grid?
+                        // It starts after Cost block.
+                        // Cost block width = widths.cost....
+                        // We need to calculate cumulative width of grid?
+                        // Implementation Simplification:
+                        // Just add " = " + balances.
+                        // The user wants alignment.
+                        // If we have explicit assertions elsewhere, `widths.assertion` will be non-zero.
+                        // We can try to align the "=" to separate column?
+                        // That requires tracking the cumulative width of (Indent + Account + Amount + Cost).
+                        // Let's Calculate the Ideal Start Column for Assertion
+                        // Indent + Account + 2 spaces + AmountBlock + CostBlock
+                        // AmountBlock width = preDecimal + decimalMark + postDecimal...
+                        // Wait, `widths` just gives MAX widths of components.
+                        // Constructing the full offset:
+                        let idealStart = formattingOptions.indentation + widths.account + 2;
+                        // Amount Block Width
+                        const amountBlockWidth = widths.amount.commodityBefore +
+                            widths.amount.spaceBetweenCommodityBeforeAndAmount +
+                            widths.amount.negPosSign +
+                            widths.amount.integerPart +
+                            widths.amount.decimalMark +
+                            widths.amount.decimalPart +
+                            widths.amount.spaceBetweenAmountAndCommodityAfter +
+                            widths.amount.commodityAfter;
+                        // Correct logic: The Amount aligns at `decimalAlignColumn`.
+                        // So the Amount Block *ends* at `decimalAlignColumn` + `postDecimalPart`.
+                        const amountPostDecimal = widths.amount.decimalMark +
+                            widths.amount.decimalPart +
+                            widths.amount.spaceBetweenAmountAndCommodityAfter +
+                            widths.amount.commodityAfter;
+                        const amountEndColumn = formattingOptions.decimalAlignColumn + amountPostDecimal;
+                        // Cost Block
+                        // Cost is appended after Amount.
+                        // Does it strictly align? 
+                        // Formatter: `line += renderAmountLayout(layout, widths.cost)`
+                        // It renders the cost width.
+                        // Unlike Amount, Cost is not decimal-aligned to a global column in the simplified logic,
+                        // it just takes up `widths.cost` space.
+                        const costBlockWidth = widths.cost.marker + // " @ "
+                            widths.cost.commodityBefore +
+                            widths.cost.spaceBetweenCommodityBeforeAndAmount +
+                            widths.cost.negPosSign +
+                            widths.cost.integerPart +
+                            widths.cost.decimalMark +
+                            widths.cost.decimalPart +
+                            widths.cost.spaceBetweenAmountAndCommodityAfter +
+                            widths.cost.commodityAfter;
+                        const costEndColumn = amountEndColumn + costBlockWidth;
+                        // So Assertion should start at `costEndColumn`.
+                        const padding = Math.max(1, costEndColumn - virtualColumn);
+                        const balanceStrings = [];
+                        for (const [comm, amount] of balanceMap) {
+                            balanceStrings.push((0, amountFormatter_1.formatAmount)(amount, comm, parsed, formattingOptions));
+                        }
+                        const balanceText = balanceStrings.join(', ');
+                        const label = ' '.repeat(padding) + '= ' + balanceText;
+                        hints.push({
+                            position: insertPosition,
+                            label: [{
+                                    value: label,
+                                    command: {
+                                        title: 'Insert balance assertion',
+                                        command: 'hledger.insertBalanceAssertion',
+                                        arguments: [document.uri, lineNum, posting.account, balanceStrings]
+                                    }
+                                }],
+                            kind: vscode_languageserver_1.InlayHintKind.Type,
+                            paddingLeft: false
+                        });
+                    }
+                }
+                postingIndex++;
             }
-            postingIndex++;
         }
         return hints;
     }