@malloydata/malloy 0.0.385 → 0.0.387

package/dist/internal.d.ts

@@ -1,3 +1,5 @@
 export { mkArrayDef, mkArrayTypeDef, mkFieldDef, mkModelDef, mkQuerySourceDef, mkSQLSourceDef, mkTableSourceDef, pathToKey, } from './model';
 export { TinyParseError, TinyParser } from './dialect/tiny_parser';
 export type { TinyToken } from './dialect/tiny_parser';
+export { prettify } from './lang/prettify';
+export type { PrettifyResult, PrettifyError } from './lang/prettify';

package/dist/internal.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TinyParser = exports.TinyParseError = exports.pathToKey = exports.mkTableSourceDef = exports.mkSQLSourceDef = exports.mkQuerySourceDef = exports.mkModelDef = exports.mkFieldDef = exports.mkArrayTypeDef = exports.mkArrayDef = void 0;
+exports.prettify = exports.TinyParser = exports.TinyParseError = exports.pathToKey = exports.mkTableSourceDef = exports.mkSQLSourceDef = exports.mkQuerySourceDef = exports.mkModelDef = exports.mkFieldDef = exports.mkArrayTypeDef = exports.mkArrayDef = void 0;
 // Unstable implementation-facing exports for Malloy packages, tests, and
 // advanced integrations. Do not treat this surface as public API.
 var model_1 = require("./model");
@@ -19,4 +19,6 @@ Object.defineProperty(exports, "pathToKey", { enumerable: true, get: function ()
 var tiny_parser_1 = require("./dialect/tiny_parser");
 Object.defineProperty(exports, "TinyParseError", { enumerable: true, get: function () { return tiny_parser_1.TinyParseError; } });
 Object.defineProperty(exports, "TinyParser", { enumerable: true, get: function () { return tiny_parser_1.TinyParser; } });
+var prettify_1 = require("./lang/prettify");
+Object.defineProperty(exports, "prettify", { enumerable: true, get: function () { return prettify_1.prettify; } });
 //# sourceMappingURL=internal.js.map

package/dist/lang/prettify/binary-chain.d.ts

@@ -0,0 +1,3 @@
+import { ParserRuleContext } from 'antlr4ts';
+import type { Formatter } from './formatter';
+export declare function formatBinaryChain(f: Formatter, ctx: ParserRuleContext): void;

package/dist/lang/prettify/binary-chain.js

@@ -0,0 +1,65 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * RULE: BINARY CHAIN — formatBinaryChain
+ *
+ * Handles `and`/`or`/`??`/`+`/`-` chains. The grammar is left-recursive, so a
+ * chain `a + b + c` parses as `((a + b) + c)`. Only the OUTERMOST chain
+ * context emits; inner same-class contexts fall through to default recursion
+ * so the outer can collect all operands.
+ *
+ * Inline if it fits. Otherwise: first operand inline; each subsequent
+ * operator+operand on its own line at +1 indent (leading-operator style).
+ *
+ * We deliberately do NOT break at comparison operators — see prettify header.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBinaryChain = formatBinaryChain;
+const antlr4ts_1 = require("antlr4ts");
+const tree_1 = require("antlr4ts/tree");
+const tokens_1 = require("./tokens");
+const leaf_1 = require("./leaf");
+function formatBinaryChain(f, ctx) {
+    // Same chain class as our parent? Then we're an inner node of the chain —
+    // let the outermost one collect all operands and emit.
+    if (ctx.parent && ctx.parent.constructor === ctx.constructor) {
+        for (let i = 0; i < ctx.childCount; i++)
+            f.format(ctx.getChild(i));
+        return;
+    }
+    const operands = [];
+    const operators = [];
+    const collect = (n) => {
+        if (n instanceof antlr4ts_1.ParserRuleContext && n.constructor === ctx.constructor) {
+            // Inner same-class chain node. Grammar guarantees getChild(1) is a
+            // TerminalNode (the operator); the guard makes that explicit without
+            // a cast.
+            collect(n.getChild(0));
+            const op = n.getChild(1);
+            if (op instanceof tree_1.TerminalNode)
+                operators.push(op);
+            operands.push(n.getChild(2));
+        }
+        else {
+            operands.push(n);
+        }
+    };
+    collect(ctx);
+    const inlineLen = (0, leaf_1.approxInlineSpan)(f, ctx._start.tokenIndex, ctx._stop.tokenIndex);
+    if (f.o.lineLengthSoFar() + 1 + inlineLen <= tokens_1.LINE_BUDGET) {
+        for (let i = 0; i < ctx.childCount; i++)
+            f.format(ctx.getChild(i));
+        return;
+    }
+    f.format(operands[0]);
+    f.o.indent++;
+    for (let i = 0; i < operators.length; i++) {
+        f.o.nl();
+        f.format(operators[i]);
+        f.format(operands[i + 1]);
+    }
+    f.o.indent--;
+}
+//# sourceMappingURL=binary-chain.js.map

package/dist/lang/prettify/block-body.d.ts

@@ -0,0 +1,4 @@
+import { ParserRuleContext } from 'antlr4ts';
+import type { Formatter } from './formatter';
+export declare function formatTopLevel(f: Formatter, ctx: ParserRuleContext): void;
+export declare function formatBlockBody(f: Formatter, ctx: ParserRuleContext): void;

package/dist/lang/prettify/block-body.js

@@ -0,0 +1,87 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * RULE: BLOCK BODY
+ *
+ * A `{ … }` body containing statements (extend body, view body, etc.). Walks
+ * children; between adjacent statements:
+ *   - `view:` definitions always get a blank line before them (and after
+ *     the previous one), regardless of whether the source had a blank or
+ *     what kind preceded — view definitions read as their own sections.
+ *   - For other kinds: preserve a single user-supplied blank line only if
+ *     the kinds differ. Same-kind adjacent statements (consecutive
+ *     dimensions, measures, etc.) never get a blank.
+ *
+ * Also: top-level body — forces a blank line before each statement after the
+ * first, regardless of source spacing (top-level statements should breathe).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTopLevel = formatTopLevel;
+exports.formatBlockBody = formatBlockBody;
+const antlr4ts_1 = require("antlr4ts");
+const tree_1 = require("antlr4ts/tree");
+const rules_1 = require("./rules");
+const tokens_1 = require("./tokens");
+const leaf_1 = require("./leaf");
+function statementKind(ctx) {
+    for (const r of rules_1.STATEMENT_KIND_BY_CTX) {
+        if (ctx instanceof r.ctxClass)
+            return r.kind;
+    }
+    return ctx.constructor.name;
+}
+function formatTopLevel(f, ctx) {
+    let emittedFirst = false;
+    for (let i = 0; i < ctx.childCount; i++) {
+        const c = ctx.getChild(i);
+        if (c instanceof tree_1.TerminalNode) {
+            const tok = c.symbol;
+            if (tok.type !== antlr4ts_1.Token.EOF)
+                (0, leaf_1.emitVisibleToken)(f, tok, tok.tokenIndex);
+            continue;
+        }
+        if (c instanceof antlr4ts_1.ParserRuleContext) {
+            if (emittedFirst)
+                f.needBlank = true;
+            f.format(c);
+            emittedFirst = true;
+        }
+    }
+}
+function formatBlockBody(f, ctx) {
+    let lastChild = null;
+    let lastChildEndLine = 0;
+    for (let i = 0; i < ctx.childCount; i++) {
+        const c = ctx.getChild(i);
+        if (c instanceof tree_1.TerminalNode) {
+            // OCURLY / CCURLY / SEMI — let the leaf walker handle them.
+            const tok = c.symbol;
+            if (tok.type !== antlr4ts_1.Token.EOF)
+                (0, leaf_1.emitVisibleToken)(f, tok, tok.tokenIndex);
+            continue;
+        }
+        if (c instanceof antlr4ts_1.ParserRuleContext) {
+            if (lastChild !== null) {
+                const userHadBlank = c._start.line - lastChildEndLine > 1;
+                const lastKind = statementKind(lastChild);
+                const curKind = statementKind(c);
+                const sameKind = lastKind === curKind;
+                // `view:` definitions always breathe — blank line above each one
+                // (and after the previous one) regardless of the user's source
+                // spacing or what kind preceded.
+                if (curKind === 'view' || lastKind === 'view') {
+                    f.o.blank();
+                }
+                else if (userHadBlank && !sameKind) {
+                    f.o.blank();
+                }
+            }
+            f.format(c);
+            lastChild = c;
+            lastChildEndLine = (0, tokens_1.endLineOf)(c._stop);
+        }
+    }
+}
+//# sourceMappingURL=block-body.js.map

package/dist/lang/prettify/error-listener.d.ts

@@ -0,0 +1,6 @@
+import type { ANTLRErrorListener, RecognitionException, Recognizer } from 'antlr4ts';
+import type { PrettifyError } from './types';
+export declare class CollectingErrorListener implements ANTLRErrorListener<any> {
+    errors: PrettifyError[];
+    syntaxError<T>(_recognizer: Recognizer<T, any>, _offendingSymbol: T | undefined, line: number, charPositionInLine: number, msg: string, _e: RecognitionException | undefined): void;
+}

package/dist/lang/prettify/error-listener.js

@@ -0,0 +1,19 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectingErrorListener = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+class CollectingErrorListener {
+    constructor() {
+        this.errors = [];
+    }
+    syntaxError(_recognizer, _offendingSymbol, line, charPositionInLine, msg, _e) {
+        this.errors.push({ message: msg, line, column: charPositionInLine });
+    }
+}
+exports.CollectingErrorListener = CollectingErrorListener;
+/* eslint-enable @typescript-eslint/no-explicit-any */
+//# sourceMappingURL=error-listener.js.map

package/dist/lang/prettify/field-properties.d.ts

@@ -0,0 +1,3 @@
+import type * as parser from '../lib/Malloy/MalloyParser';
+import type { Formatter } from './formatter';
+export declare function formatFieldProperties(f: Formatter, ctx: parser.FieldPropertiesContext): void;

package/dist/lang/prettify/field-properties.js

@@ -0,0 +1,57 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * RULE: POSTFIX `{…}` — formatFieldProperties
+ *
+ * `expr { kw: ... }` — filter shortcut and friends. Inline if it fits;
+ * otherwise emit as a block with each inner statement on its own line. Inner
+ * statements are rendered atomically via formatTokenRange (no recursive
+ * section-list rewriting): they're part of the expression.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFieldProperties = formatFieldProperties;
+const antlr4ts_1 = require("antlr4ts");
+const tokens_1 = require("./tokens");
+const leaf_1 = require("./leaf");
+const inline_renderer_1 = require("./inline-renderer");
+function formatFieldProperties(f, ctx) {
+    const startIdx = ctx._start.tokenIndex;
+    const stopIdx = ctx._stop.tokenIndex;
+    const hasComments = (0, leaf_1.hasCommentsInRange)(f, startIdx, stopIdx);
+    if (!hasComments) {
+        const inline = (0, inline_renderer_1.renderItemInline)(f, ctx);
+        if (f.o.lineLengthSoFar() + 1 + inline.length <= tokens_1.LINE_BUDGET) {
+            f.o.space();
+            f.o.text(inline);
+            (0, leaf_1.note)(f, tokens_1.L.CCURLY, stopIdx, ctx._stop);
+            return;
+        }
+    }
+    // Wrapped form. Each inner statement runs through the leaf walker
+    // (formatTokenRange) so comments inside it are preserved naturally.
+    f.o.space();
+    f.o.text('{');
+    f.o.indent++;
+    // Advance past the OCURLY ourselves so flushHiddenBefore for the first inner
+    // statement doesn't try to re-emit it.
+    f.lastEmittedIdx = startIdx;
+    for (let i = 0; i < ctx.childCount; i++) {
+        const c = ctx.getChild(i);
+        // Skip OCURLY / CCURLY / SEMI; only inner statement contexts get walked.
+        if (!(c instanceof antlr4ts_1.ParserRuleContext))
+            continue;
+        f.o.nl();
+        (0, leaf_1.formatTokenRange)(f, c._start.tokenIndex, c._stop.tokenIndex);
+    }
+    // Flush any tail hidden tokens between the last inner statement and the
+    // closing `}` so trailing comments emit at the inner indent rather than
+    // disappearing.
+    (0, leaf_1.flushHiddenBefore)(f, stopIdx);
+    f.o.indent--;
+    f.o.nl();
+    f.o.text('}');
+    (0, leaf_1.note)(f, tokens_1.L.CCURLY, stopIdx, ctx._stop);
+}
+//# sourceMappingURL=field-properties.js.map

package/dist/lang/prettify/formatter.d.ts

@@ -0,0 +1,17 @@
+import { Token } from 'antlr4ts';
+import type { ParseTree } from 'antlr4ts/tree';
+import { Out } from './out';
+export declare class Formatter {
+    readonly src: string;
+    readonly tokens: Token[];
+    o: Out;
+    lastEmittedIdx: number;
+    lastEmittedType: number | null;
+    prevTokenEndLine: number;
+    needBlank: boolean;
+    parenDepth: number;
+    parenBreaks: boolean[];
+    private rootFormatted;
+    constructor(src: string, tokens: Token[]);
+    format(node: ParseTree): void;
+}

package/dist/lang/prettify/formatter.js

@@ -0,0 +1,150 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * Formatter: per-format-call state container plus the parse-tree dispatcher.
+ *
+ * State (Out buffer, last-emitted token tracking, paren-depth stack) is
+ * mutable and read/written directly by the per-rule free functions in sibling
+ * modules. The dispatcher is the only method on the class — it routes each
+ * parse-tree node to the appropriate per-rule formatter, falling back to
+ * left-to-right child recursion.
+ *
+ * The class itself is not exported beyond ./index, so its fields being
+ * "package-public" is hygiene only — no external API leakage.
+ */
+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.Formatter = void 0;
+const antlr4ts_1 = require("antlr4ts");
+const tree_1 = require("antlr4ts/tree");
+const parser = __importStar(require("../lib/Malloy/MalloyParser"));
+const out_1 = require("./out");
+const rules_1 = require("./rules");
+const leaf_1 = require("./leaf");
+const block_body_1 = require("./block-body");
+const sections_1 = require("./sections");
+const field_properties_1 = require("./field-properties");
+const pick_case_1 = require("./pick-case");
+const binary_chain_1 = require("./binary-chain");
+const import_select_1 = require("./import-select");
+class Formatter {
+    constructor(src, tokens) {
+        this.src = src;
+        this.tokens = tokens;
+        this.o = new out_1.Out();
+        // -- Per-token state (updated by `note(f, ...)` after every token emit) --
+        // Index of the last token (visible or implicitly skipped) we've accounted
+        // for. flushHiddenBefore won't re-emit anything at or before this index.
+        this.lastEmittedIdx = -1;
+        // Type of the last visible token emitted. Drives spacing decisions
+        // (e.g. CALL_HUG_AFTER membership for `(`).
+        this.lastEmittedType = null;
+        // 1-based line in the SOURCE where the last emitted token ended. Used to
+        // distinguish trailing-comments (same line) from leading-comments (different
+        // line).
+        this.prevTokenEndLine = 0;
+        // After end-of-top-level-statement, the next statement-starter gets a blank
+        // line. Consumed once, then reset.
+        this.needBlank = false;
+        // -- Paren-pair state --
+        this.parenDepth = 0;
+        // For each open paren-pair: did we choose to break args/content across
+        // lines? Stack matches parenDepth.
+        this.parenBreaks = [];
+        // Set when format() is invoked at the top level (a MalloyDocument). Guards
+        // against accidental reuse of a Formatter instance — the Out buffer
+        // accumulates and would emit garbage on a second call. Construct a fresh
+        // Formatter per top-level call.
+        this.rootFormatted = false;
+    }
+    format(node) {
+        if (node instanceof tree_1.TerminalNode) {
+            const tok = node.symbol;
+            if (tok.type !== antlr4ts_1.Token.EOF)
+                (0, leaf_1.emitVisibleToken)(this, tok, tok.tokenIndex);
+            return;
+        }
+        if (!(node instanceof antlr4ts_1.ParserRuleContext))
+            return;
+        // RULE: TOP-LEVEL BODY — one blank line between adjacent statements.
+        if (node instanceof parser.MalloyDocumentContext) {
+            if (this.rootFormatted) {
+                throw new Error('Formatter is single-use; construct a new instance per top-level format call');
+            }
+            this.rootFormatted = true;
+            return (0, block_body_1.formatTopLevel)(this, node);
+        }
+        // RULE: POSTFIX `{…}` — filter shortcut etc.
+        if (node instanceof parser.FieldPropertiesContext) {
+            return (0, field_properties_1.formatFieldProperties)(this, node);
+        }
+        // RULE: BLOCK BODY — walk children, blank-lines between different kinds.
+        if (node instanceof parser.ExplorePropertiesContext ||
+            node instanceof parser.QueryPropertiesContext ||
+            node instanceof parser.QueryExtendStatementListContext) {
+            return (0, block_body_1.formatBlockBody)(this, node);
+        }
+        // RULE: SECTION-STATEMENT — table-driven dispatch.
+        for (const rule of rules_1.SECTION_STATEMENT_RULES) {
+            if (node instanceof rule.ctxClass) {
+                return (0, sections_1.formatSectionStatement)(this, node, rule);
+            }
+        }
+        // RULE: IMPORT SELECT — `import {a, b} from 'x'` stays compact.
+        if (node instanceof parser.ImportSelectContext) {
+            return (0, import_select_1.formatImportSelect)(this, node);
+        }
+        // RULE: PICK / CASE / BINARY CHAIN.
+        if (node instanceof parser.PickStatementContext)
+            return (0, pick_case_1.formatPickStatement)(this, node);
+        if (node instanceof parser.PickContext)
+            return (0, pick_case_1.formatPick)(this, node);
+        if (node instanceof parser.CaseStatementContext)
+            return (0, pick_case_1.formatCaseStatement)(this, node);
+        if (node instanceof parser.ExprLogicalAndContext ||
+            node instanceof parser.ExprLogicalOrContext ||
+            node instanceof parser.ExprCoalesceContext ||
+            node instanceof parser.ExprAddSubContext) {
+            return (0, binary_chain_1.formatBinaryChain)(this, node);
+        }
+        // Default: recurse on children left-to-right.
+        for (let i = 0; i < node.childCount; i++)
+            this.format(node.getChild(i));
+    }
+}
+exports.Formatter = Formatter;
+//# sourceMappingURL=formatter.js.map

package/dist/lang/prettify/import-select.d.ts

@@ -0,0 +1,3 @@
+import type * as parser from '../lib/Malloy/MalloyParser';
+import type { Formatter } from './formatter';
+export declare function formatImportSelect(f: Formatter, ctx: parser.ImportSelectContext): void;

package/dist/lang/prettify/import-select.js

@@ -0,0 +1,88 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * RULE: IMPORT SELECT — `import {a, b, c} from 'url'`
+ *
+ * The selection list is `{ id (IS id)? (, id (IS id)?)* }`. Inline if the
+ * whole brace-and-contents fits on the current line. Otherwise wrap with
+ * each item on its own line at +1 indent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatImportSelect = formatImportSelect;
+const tokens_1 = require("./tokens");
+const leaf_1 = require("./leaf");
+const inline_renderer_1 = require("./inline-renderer");
+function formatImportSelect(f, ctx) {
+    // Flush hidden tokens between the previous emit (IMPORT) and our opener
+    // so a comment like `import /* tag */ {a} from 'x'` is preserved.
+    (0, leaf_1.flushHiddenBefore)(f, ctx._start.tokenIndex);
+    const items = ctx.importItem();
+    // Grammar puts FROM as the last token of importSelect: emit it ourselves
+    // so the trailing space and lastEmittedIdx land correctly.
+    const fromTok = ctx.FROM().symbol;
+    const fromIdx = fromTok.tokenIndex;
+    if (items.length === 0) {
+        f.o.space();
+        f.o.text('{} from');
+        (0, leaf_1.note)(f, tokens_1.L.FROM, fromIdx, fromTok);
+        return;
+    }
+    const firstItem = items[0];
+    const lastItem = items[items.length - 1];
+    // Comments anywhere in the items' span (between items, inside an `as is`
+    // form, etc.) get stripped by renderItemInline. Fall back to a comment-
+    // safe wrap that emits each item via f.format — the leaf walker handles
+    // hidden-channel placement.
+    const itemsHaveComments = (0, leaf_1.hasCommentsInRange)(f, firstItem._start.tokenIndex, lastItem._stop.tokenIndex);
+    if (!itemsHaveComments) {
+        const itemStrs = items.map(it => (0, inline_renderer_1.renderItemInline)(f, it));
+        const inlineBody = '{' + itemStrs.join(', ') + '} from';
+        if (f.o.lineLengthSoFar() + 1 + inlineBody.length <= tokens_1.LINE_BUDGET) {
+            f.o.space();
+            f.o.text(inlineBody);
+            (0, leaf_1.note)(f, tokens_1.L.FROM, fromIdx, fromTok);
+            return;
+        }
+        // Wrap form (no comments): one item per line at +1 indent. Pre-rendered
+        // text is fine because renderItemInline saw no comments to drop.
+        f.o.space();
+        f.o.text('{');
+        f.o.indent++;
+        for (let i = 0; i < itemStrs.length; i++) {
+            f.o.nl();
+            f.o.text(itemStrs[i]);
+            if (i < itemStrs.length - 1)
+                f.o.text(',');
+        }
+        f.o.indent--;
+        f.o.nl();
+        f.o.text('} from');
+        (0, leaf_1.note)(f, tokens_1.L.FROM, fromIdx, fromTok);
+        return;
+    }
+    // Comment-safe wrap: each item emits via f.format so flushHiddenBefore
+    // can place its leading/inter-item comments correctly. Trailing `,` after
+    // each non-last item, leaf walker turns it into a newline at indent.
+    f.o.space();
+    f.o.text('{');
+    f.o.indent++;
+    // Advance past the OCURLY we just emitted manually so the first item's
+    // flushHiddenBefore doesn't try to re-emit it.
+    f.lastEmittedIdx = ctx._start.tokenIndex;
+    for (let i = 0; i < items.length; i++) {
+        (0, leaf_1.flushHiddenBefore)(f, items[i]._start.tokenIndex);
+        f.o.nl();
+        f.format(items[i]);
+        if (i < items.length - 1)
+            f.o.text(',');
+    }
+    // Catch any tail comments between the last item and the closing `}`.
+    (0, leaf_1.flushHiddenBefore)(f, fromIdx);
+    f.o.indent--;
+    f.o.nl();
+    f.o.text('} from');
+    (0, leaf_1.note)(f, tokens_1.L.FROM, fromIdx, fromTok);
+}
+//# sourceMappingURL=import-select.js.map

package/dist/lang/prettify/index.d.ts

@@ -0,0 +1,19 @@
+import type { PrettifyResult } from './types';
+export type { PrettifyError, PrettifyResult } from './types';
+/**
+ * Pretty-print a Malloy source string.
+ *
+ * **Experimental — this API may vanish or change at any time without notice.**
+ * It is exposed only via `@malloydata/malloy/internal` and is not covered by
+ * any compatibility commitment. Do not depend on it from anything you can't
+ * fix in a single PR.
+ *
+ * Parses the input, walks the parse tree, and emits a reformatted string.
+ *
+ * `errors` surfaces parse errors only (lexer + parser). Semantic / compile
+ * errors aren't checked here. If `errors.length > 0` you have a bigger problem
+ * than formatting — output is best-effort and not guaranteed to round-trip.
+ *
+ * @experimental
+ */
+export declare function prettify(src: string): PrettifyResult;