@malloydata/malloy 0.0.384 → 0.0.386

package/dist/api/foundation/config_resolve.js

@@ -77,32 +77,24 @@ function extractCompiledConnections(node) {
     return out;
 }
 /**
- * Add a bare `{is: typeName}` compiled entry for each registered connection
- * type not already represented in `compiledConnections`. Only runs when the
- * POJO sets `includeDefaultConnections: true`. Property values (including
- * reference-shaped defaults like DuckDB's `{config: 'rootDirectory'}`) are
- * *not* filled in here — that is the job of the async lookup resolver.
+ * For each registered connection type T, add a bare `{is: T}` compiled
+ * entry named T unless one already exists under that name. Only runs when
+ * the POJO sets `includeDefaultConnections: true`. Property values
+ * (including reference-shaped defaults like DuckDB's
+ * `{config: 'rootDirectory'}`) are filled in later by the async lookup
+ * resolver, not here.
  *
- * Skip rules:
- *   - Type already in use: some existing entry has `is: typeName`.
- *   - Name already taken: some existing entry is *named* `typeName`, even
- *     if its `is` points elsewhere. This protects a user who writes
- *     `{duckdb: {is: 'postgres', ...}}` — naming an entry after a type but
- *     pointing at a different backend — from being clobbered.
+ * The skip is purely name-based: the `is` of a user entry is irrelevant.
+ * `{duckdb: {is: 'postgres'}}` shadows the duckdb phantom (slot taken);
+ * `{dankdb: {is: 'duckdb'}}` does not (slot `duckdb` is still free, and
+ * both end up reachable). This name-only rule is the contract hosts rely
+ * on — e.g. the VS Code connections sidebar advertises defaults by name,
+ * and the runtime must resolve them under those same names.
  *
  * Mutates `compiledConnections` in place.
  */
 function fabricateMissingConnections(compiledConnections) {
-    const presentTypes = new Set();
-    for (const entry of Object.values(compiledConnections)) {
-        const isNode = entry.entries['is'];
-        if ((isNode === null || isNode === void 0 ? void 0 : isNode.kind) === 'value' && typeof isNode.value === 'string') {
-            presentTypes.add(isNode.value);
-        }
-    }
     for (const typeName of (0, registry_1.getRegisteredConnectionTypes)()) {
-        if (presentTypes.has(typeName))
-            continue;
         if (compiledConnections[typeName])
             continue;
         compiledConnections[typeName] = {

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,74 @@
+"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, preserves a single user-supplied
+ * blank line *only if the kinds differ*. Same-kind adjacent statements 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 sameKind = statementKind(lastChild) === statementKind(c);
+                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,145 @@
+"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");
+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: 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/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;

package/dist/lang/prettify/index.js

@@ -0,0 +1,139 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * ============================================================================
+ * Malloy pretty-printer (experimental, /internal export — no stability promise)
+ * ============================================================================
+ *
+ * Architecture
+ * ------------
+ *   1. Lex + parse the input.
+ *   2. Walk the parse tree from `Formatter.format(node)`. The dispatcher routes
+ *      each rule context to a per-rule free function in a sibling module;
+ *      everything unhandled recurses to children, eventually reaching terminal
+ *      tokens that emit through `emitVisibleToken` (the leaf).
+ *   3. The leaf walker handles per-token spacing/indentation/comments. It is
+ *      v1's behaviour and is also the fallback when parsing fails.
+ *
+ * File layout
+ * -----------
+ *   - ./out                — Out buffer (indent, newlines, single-space coalescing).
+ *   - ./tokens             — LINE_BUDGET, INDENT_STR; classification sets
+ *                            (SECTION_TOKENS, BINARY_OPS, CALL_HUG_AFTER, etc.);
+ *                            findMatching, endLineOf.
+ *   - ./rules              — SECTION_STATEMENT_RULES + STATEMENT_KIND_BY_CTX.
+ *                            A maintainer adding a new section keyword lands here.
+ *   - ./error-listener     — CollectingErrorListener.
+ *   - ./types              — PrettifyError, PrettifyResult.
+ *   - ./formatter          — Formatter class (state + format() dispatcher).
+ *   - ./leaf               — emitVisibleToken + per-token state mutators
+ *                            (note, flushHiddenBefore, startStatementLine, …)
+ *                            and the small read-only helpers used by rule
+ *                            formatters (approxInlineSpan, hasCommentsInRange,
+ *                            formatTokenRange).
+ *   - ./inline-renderer    — renderItemInline (flat-string form for budget
+ *                            measurement and column alignment).
+ *   - ./block-body         — formatBlockBody, formatTopLevel.
+ *   - ./sections           — formatSectionStatement / formatSectionList.
+ *   - ./field-properties   — formatFieldProperties (postfix `{…}`).
+ *   - ./pick-case          — formatPickStatement, formatCaseStatement.
+ *   - ./binary-chain       — formatBinaryChain.
+ *   - ./index (this)       — prettify() entry point + type re-exports.
+ *
+ * Decisions worth knowing
+ * -----------------------
+ *   - Comparison operators (`=`, `!=`, `<`, `>`, …) are kept glued to their
+ *     operands. We only break chains at and/or/??/+/-. Justification: LHS/RHS
+ *     of a comparison reads as one unit; breaking inside is more confusing
+ *     than the line being long.
+ *   - SQL strings (`"""…"""`, including `%{…}` malloy interpolations) and
+ *     block annotations (`#" … "`) are emitted verbatim from source. We don't
+ *     own a SQL formatter; annotation indentation is significant.
+ *   - `;` is the compact-inline statement separator. Wrapped form drops it
+ *     (newlines do the job); inline form keeps it.
+ *   - `,` in section-list bare flow: intra-line yes, end-of-line never.
+ *   - Single-arg function calls don't wrap (no point — nowhere useful to break).
+ *   - `(` hugs only after a known-callable token (CALL_HUG_AFTER); after `is`,
+ *     `as`, `extend`, `on`, `when`, etc. the `(` is grouping and gets a space.
+ *
+ * Adding a new section-statement
+ * ------------------------------
+ *   Add a row to SECTION_STATEMENT_RULES in ./rules with the rule's context
+ *   class, the keyword token type(s), the list-context accessor, and the
+ *   item-kind tag. Add a corresponding entry to listItems() in ./sections.
+ *
+ *   Note: section keywords NOT in the table fall through to the leaf walker
+ *   (which produces correct-but-plain output). Add a row only when the default
+ *   isn't good enough — flow-fill, alignment, or annotation handling.
+ *
+ * Inter-token spacing
+ * -------------------
+ *   The classifier `leadingAction(prev, next)` in ./tokens is the single
+ *   source of truth for what separator (glue, hug, or coalescing space) goes
+ *   between two adjacent tokens. Both walkers — emitVisibleToken in ./leaf
+ *   and renderItemInline in ./inline-renderer — consult it, so a change to
+ *   `leadingAction` (e.g. adding a token type that hugs `(`) takes effect in
+ *   both paths automatically. Walker-specific concerns (newlines, indent,
+ *   paren-wrap decisions, compact-inline `, ` / `; `) live in the walker.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettify = prettify;
+const antlr4ts_1 = require("antlr4ts");
+const run_malloy_parser_1 = require("../run-malloy-parser");
+const error_listener_1 = require("./error-listener");
+const formatter_1 = require("./formatter");
+const leaf_1 = require("./leaf");
+/**
+ * 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
+ */
+function prettify(src) {
+    const lexerErrors = new error_listener_1.CollectingErrorListener();
+    const parserErrors = new error_listener_1.CollectingErrorListener();
+    const { tokenStream, parser: malloyParser } = (0, run_malloy_parser_1.makeMalloyParser)(src, {
+        lexerErrorListener: lexerErrors,
+        parserErrorListener: parserErrors,
+    });
+    tokenStream.fill();
+    const tokens = tokenStream.getTokens();
+    let root = null;
+    try {
+        root = malloyParser.malloyDocument();
+    }
+    catch {
+        root = null;
+    }
+    const f = new formatter_1.Formatter(src, tokens);
+    if (root) {
+        f.format(root);
+    }
+    else {
+        // Parse failed. Fall back to leaf-only emission so we still produce
+        // something reasonable.
+        for (let i = 0; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (t.channel !== antlr4ts_1.Token.HIDDEN_CHANNEL && t.type !== antlr4ts_1.Token.EOF) {
+                (0, leaf_1.emitVisibleToken)(f, t, i);
+            }
+        }
+    }
+    return {
+        result: f.o.toString(),
+        errors: [...lexerErrors.errors, ...parserErrors.errors],
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/lang/prettify/inline-renderer.d.ts

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