@malloydata/malloy 0.0.386 → 0.0.388

package/dist/api/foundation/config.d.ts

@@ -133,27 +133,42 @@ export declare class MalloyConfig {
      */
     wrapConnections(wrapper: (base: LookupConnection<Connection>) => LookupConnection<Connection>): void;
     /**
-     * Notify every connection this config has handed out that it is time to
-     * release its resources, then drop them from the internal cache.
+     * Notify every connection this config has handed out that the host is
+     * done with it, applying the requested disposition to its backend
+     * resources. Two policies:
      *
-     * Most callers should use `Runtime.releaseConnections()` instead — the
-     * expected contract is one MalloyConfig per Runtime, and the runtime is
-     * the natural handle for lifecycle. This method exists because Runtime
+     * - `'close'` (default) — destructive. Calls `Connection.close()` on each
+     *   cached entry and drops the cache. Subsequent operations on those
+     *   connection objects may fail. Use this at real shutdown: process
+     *   exit, extension deactivate, config-file change.
+     *
+     * - `'idle'` — reversible. Calls `Connection.idle()` on each cached entry
+     *   without dropping the cache. The same Connection objects are reused
+     *   on next lookup; schema cache and other in-process state survive.
+     *   The next operation transparently reattaches any backend resources
+     *   that were released. Use this between operations in long-lived hosts
+     *   (VSCode, MCP servers, anything that builds Runtimes per request) to
+     *   release file locks / pooled sockets while the host is otherwise
+     *   idle.
+     *
+     * Most callers should use `Runtime.shutdown(...)` instead — the expected
+     * contract is one MalloyConfig per Runtime, and the runtime is the
+     * natural handle for lifecycle. This method exists because Runtime
      * forwards to it, and for the rare case of a MalloyConfig constructed
      * without an accompanying Runtime.
      *
      * MalloyConfig does not own any connection resources itself — pools,
      * sockets, file handles, and in-process databases all live inside the
      * individual Connection objects. What the managed lookup owns is a cache
-     * of `name → Connection` populated lazily as callers request connections.
-     * This method walks that cache and calls `Connection.close()` on each
-     * entry, which is the signal each connection uses to shut down whatever
-     * resources it actually holds.
-     *
-     * Connections that were never looked up were never constructed and have
-     * nothing to release; they are skipped. Wrapping lookups installed via
-     * `wrapConnections()` do not interfere — the managed lookup under the
-     * wrap is the one holding the cache.
+     * of `name → Connection` populated lazily as callers request
+     * connections. Connections that were never looked up were never
+     * constructed and have nothing to release; they are skipped. Wrapping
+     * lookups installed via `wrapConnections()` do not interfere — the
+     * managed lookup under the wrap is the one holding the cache.
+     */
+    shutdown(connections?: 'close' | 'idle'): Promise<void>;
+    /**
+     * @deprecated Use `shutdown('close')` instead.
      */
     releaseConnections(): Promise<void>;
     /**

package/dist/api/foundation/config.js

@@ -216,30 +216,52 @@ class MalloyConfig {
         this._connections = wrapper(this._connections);
     }
     /**
-     * Notify every connection this config has handed out that it is time to
-     * release its resources, then drop them from the internal cache.
+     * Notify every connection this config has handed out that the host is
+     * done with it, applying the requested disposition to its backend
+     * resources. Two policies:
      *
-     * Most callers should use `Runtime.releaseConnections()` instead — the
-     * expected contract is one MalloyConfig per Runtime, and the runtime is
-     * the natural handle for lifecycle. This method exists because Runtime
+     * - `'close'` (default) — destructive. Calls `Connection.close()` on each
+     *   cached entry and drops the cache. Subsequent operations on those
+     *   connection objects may fail. Use this at real shutdown: process
+     *   exit, extension deactivate, config-file change.
+     *
+     * - `'idle'` — reversible. Calls `Connection.idle()` on each cached entry
+     *   without dropping the cache. The same Connection objects are reused
+     *   on next lookup; schema cache and other in-process state survive.
+     *   The next operation transparently reattaches any backend resources
+     *   that were released. Use this between operations in long-lived hosts
+     *   (VSCode, MCP servers, anything that builds Runtimes per request) to
+     *   release file locks / pooled sockets while the host is otherwise
+     *   idle.
+     *
+     * Most callers should use `Runtime.shutdown(...)` instead — the expected
+     * contract is one MalloyConfig per Runtime, and the runtime is the
+     * natural handle for lifecycle. This method exists because Runtime
      * forwards to it, and for the rare case of a MalloyConfig constructed
      * without an accompanying Runtime.
      *
      * MalloyConfig does not own any connection resources itself — pools,
      * sockets, file handles, and in-process databases all live inside the
      * individual Connection objects. What the managed lookup owns is a cache
-     * of `name → Connection` populated lazily as callers request connections.
-     * This method walks that cache and calls `Connection.close()` on each
-     * entry, which is the signal each connection uses to shut down whatever
-     * resources it actually holds.
-     *
-     * Connections that were never looked up were never constructed and have
-     * nothing to release; they are skipped. Wrapping lookups installed via
-     * `wrapConnections()` do not interfere — the managed lookup under the
-     * wrap is the one holding the cache.
+     * of `name → Connection` populated lazily as callers request
+     * connections. Connections that were never looked up were never
+     * constructed and have nothing to release; they are skipped. Wrapping
+     * lookups installed via `wrapConnections()` do not interfere — the
+     * managed lookup under the wrap is the one holding the cache.
+     */
+    async shutdown(connections = 'close') {
+        if (connections === 'idle') {
+            await this._managedLookup.idle();
+        }
+        else {
+            await this._managedLookup.close();
+        }
+    }
+    /**
+     * @deprecated Use `shutdown('close')` instead.
      */
     async releaseConnections() {
-        await this._managedLookup.close();
+        await this.shutdown('close');
     }
     /**
      * Query a value from the overlays used to resolve this config.

package/dist/api/foundation/config_lookup.js

@@ -83,6 +83,13 @@ function buildManagedLookup(compiledConnections, overlays, log) {
                 await conn.close();
             }
         },
+        async idle() {
+            // Cache is preserved — same Connection objects are reused so that
+            // schema cache and other in-process state survive the idle.
+            for (const conn of cache.values()) {
+                await conn.idle();
+            }
+        },
     };
 }
 /**
@@ -91,7 +98,14 @@ function buildManagedLookup(compiledConnections, overlays, log) {
  * gets handed to the factory.
  */
 async function resolveCompiledEntry(entry, overlays, log) {
-    const resolved = (await resolveNode(entry, overlays, log));
+    const resolved = await resolveNode(entry, overlays, log);
+    // resolveNode returns `unknown`. The compileConnections pipeline
+    // guarantees every connection entry is an object dict with `is` set to
+    // a literal string, so this should always pass — but a structured
+    // throw beats a downstream NPE if a compiler bug ever sneaks through.
+    if (!(0, registry_1.isConnectionConfigEntry)(resolved)) {
+        throw new Error('Connection entry did not resolve to a valid {is: string, ...} dict');
+    }
     await applyPropertyDefaults(resolved, overlays);
     return resolved;
 }

package/dist/api/foundation/runtime.d.ts

@@ -126,16 +126,27 @@ export declare class Runtime {
     get virtualMap(): VirtualMap | undefined;
     set virtualMap(map: VirtualMap | undefined);
     /**
-     * Notify every connection this runtime's config has handed out that it
-     * is time to release its resources (pools, sockets, file handles,
-     * in-process databases). A no-op for runtimes constructed without a
-     * MalloyConfig — in that case the caller owns the connections they
-     * passed in and is responsible for closing them.
-     *
-     * The expected contract is one MalloyConfig per Runtime. Long-running
-     * hosts (Publisher, a VS Code extension tearing down a project) should
-     * call this when a runtime goes out of scope; one-shot CLIs can skip it
-     * and let process exit clean up.
+     * Tell this runtime's connections what to do with their backend
+     * resources now that the host is done with this Runtime. Two policies:
+     *
+     * - `'close'` (default) — destructive shutdown. Connections release
+     *   resources and become unusable. Use at real shutdown: process exit,
+     *   extension deactivate, config-file change.
+     *
+     * - `'idle'` — reversible release. Connections release expensive
+     *   resources (DuckDB file locks, socket pools) but stay logically
+     *   valid. The same Connection objects are reused on next lookup;
+     *   schema cache and other in-process state survive. Use between
+     *   operations in long-lived hosts (a VSCode extension, an MCP server,
+     *   any host that builds Runtimes per request) so that other writers
+     *   can claim resources during idle gaps.
+     *
+     * A no-op for runtimes constructed without a MalloyConfig — in that
+     * case the caller owns the connections they passed in.
+     */
+    shutdown(connections?: 'close' | 'idle'): Promise<void>;
+    /**
+     * @deprecated Use `shutdown('close')` instead.
      */
     releaseConnections(): Promise<void>;
     /**

package/dist/api/foundation/runtime.js

@@ -160,7 +160,11 @@ class Runtime {
                     return undefined;
                 }
                 try {
-                    return JSON.parse(text);
+                    const parsed = JSON.parse(text);
+                    if (!isBuildManifestShape(parsed)) {
+                        throw new Error('manifest is not an object with an "entries" map');
+                    }
+                    return parsed;
                 }
                 catch (e) {
                     // File was present but couldn't be parsed. Return an empty
@@ -193,20 +197,33 @@ class Runtime {
         this._virtualMap = map;
     }
     /**
-     * Notify every connection this runtime's config has handed out that it
-     * is time to release its resources (pools, sockets, file handles,
-     * in-process databases). A no-op for runtimes constructed without a
-     * MalloyConfig — in that case the caller owns the connections they
-     * passed in and is responsible for closing them.
+     * Tell this runtime's connections what to do with their backend
+     * resources now that the host is done with this Runtime. Two policies:
+     *
+     * - `'close'` (default) — destructive shutdown. Connections release
+     *   resources and become unusable. Use at real shutdown: process exit,
+     *   extension deactivate, config-file change.
+     *
+     * - `'idle'` — reversible release. Connections release expensive
+     *   resources (DuckDB file locks, socket pools) but stay logically
+     *   valid. The same Connection objects are reused on next lookup;
+     *   schema cache and other in-process state survive. Use between
+     *   operations in long-lived hosts (a VSCode extension, an MCP server,
+     *   any host that builds Runtimes per request) so that other writers
+     *   can claim resources during idle gaps.
      *
-     * The expected contract is one MalloyConfig per Runtime. Long-running
-     * hosts (Publisher, a VS Code extension tearing down a project) should
-     * call this when a runtime goes out of scope; one-shot CLIs can skip it
-     * and let process exit clean up.
+     * A no-op for runtimes constructed without a MalloyConfig — in that
+     * case the caller owns the connections they passed in.
      */
-    async releaseConnections() {
+    async shutdown(connections = 'close') {
         var _a;
-        await ((_a = this._config) === null || _a === void 0 ? void 0 : _a.releaseConnections());
+        await ((_a = this._config) === null || _a === void 0 ? void 0 : _a.shutdown(connections));
+    }
+    /**
+     * @deprecated Use `shutdown('close')` instead.
+     */
+    async releaseConnections() {
+        await this.shutdown('close');
     }
     /**
      * Load a Malloy model by URL or contents.
@@ -532,7 +549,7 @@ class ModelMaterializer extends FluentState {
         const result = await this.loadQuery(searchMapMalloy, options).run({
             rowLimit: 1000,
         });
-        const rawResult = result._queryResult.result;
+        const rawResult = result.data.toObject();
         return rawResult.map(row => ({
             ...row,
             cardinality: (0, row_data_utils_1.rowDataToNumber)(row.cardinality),
@@ -870,4 +887,18 @@ class ExploreMaterializer extends FluentState {
     }
 }
 exports.ExploreMaterializer = ExploreMaterializer;
+/**
+ * Structural check for the `BuildManifest` shape: a non-null object with an
+ * object `entries` field. Doesn't validate every entry — `BuildManifestEntry`
+ * is just `{tableName: string}`, so a stricter walk could come later if we
+ * find malformed entries causing trouble. The current goal is to fail
+ * cleanly on a manifest file that parsed to a string/array/null instead of
+ * leaving a downstream `entries[buildId]` lookup to crash on `undefined`.
+ */
+function isBuildManifestShape(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const entries = value.entries;
+    return typeof entries === 'object' && entries !== null;
+}
 //# sourceMappingURL=runtime.js.map

package/dist/connection/base_connection.d.ts

@@ -40,6 +40,7 @@ export declare abstract class BaseConnection implements Connection {
     canPersist(): this is PersistSQLResults;
     canStream(): this is StreamingConnection;
     close(): Promise<void>;
+    idle(): Promise<void>;
     estimateQueryCost(_sqlCommand: string): Promise<QueryRunStats>;
     fetchMetadata(): Promise<{}>;
     fetchTableMetadata(_tablePath: string): Promise<{}>;

package/dist/connection/base_connection.js

@@ -78,6 +78,7 @@ class BaseConnection {
         return false;
     }
     async close() { }
+    async idle() { }
     async estimateQueryCost(_sqlCommand) {
         return {};
     }

package/dist/connection/registry.d.ts

@@ -122,11 +122,14 @@ export declare function readConnectionsConfig(jsonText: string): ConnectionsConf
 export declare function writeConnectionsConfig(config: ConnectionsConfig): string;
 /**
  * A LookupConnection with lifecycle management: close() shuts down all
- * cached connections, and an optional onConnectionCreated callback fires
- * once per connection after factory creation (before caching).
+ * cached connections, idle() releases their backend resources but keeps
+ * the cache so the same connection objects are reused on next lookup, and
+ * an optional onConnectionCreated callback fires once per connection after
+ * factory creation (before caching).
  */
 export interface ManagedConnectionLookup extends LookupConnection<Connection> {
     close(): Promise<void>;
+    idle(): Promise<void>;
 }
 /**
  * Create a ManagedConnectionLookup from a ConnectionsConfig using registered

package/dist/connection/registry.js

@@ -159,6 +159,13 @@ function createConnectionsFromConfig(config, onConnectionCreated) {
                 await conn.close();
             }
         },
+        async idle() {
+            // Cache is preserved — the same Connection objects are reused so that
+            // schema cache and other in-process state survive the idle.
+            for (const conn of cache.values()) {
+                await conn.idle();
+            }
+        },
     };
 }
 //# sourceMappingURL=registry.js.map

package/dist/connection/types.d.ts

@@ -77,6 +77,20 @@ export interface Connection extends InfoConnection {
     canPersist(): this is PersistSQLResults;
     canStream(): this is StreamingConnection;
     close(): Promise<void>;
+    /**
+     * Release expensive backend resources (file locks, sockets, sub-processes,
+     * pooled connections) but remain logically valid. The next operation
+     * transparently reattaches whatever was released; schema cache and other
+     * in-process state survive.
+     *
+     * The default is a no-op for backends that hold no release-able resources
+     * between operations. Backends that hold OS-level resources (DuckDB file
+     * locks, persistent socket pools) should override.
+     *
+     * Hosts that share a connection across concurrent operations should not
+     * call `idle()` while an operation is in flight.
+     */
+    idle(): Promise<void>;
     estimateQueryCost(sqlCommand: string): Promise<QueryRunStats>;
     fetchMetadata: () => Promise<ConnectionMetadata>;
     fetchTableMetadata: (tablePath: string) => Promise<TableMetadata>;

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

@@ -6,9 +6,13 @@
  * 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.
+ * 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).
@@ -61,9 +65,18 @@ function formatBlockBody(f, ctx) {
         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)
+                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;

package/dist/lang/prettify/formatter.js

@@ -60,6 +60,7 @@ 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;
@@ -123,6 +124,10 @@ class Formatter {
                 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);

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.js

@@ -57,6 +57,30 @@
  *   - 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.
+ *     CALL_HUG_AFTER includes the keyword-named built-ins that are commonly
+ *     used as functions: ALL, EXCLUDE, the timeframe truncation keywords
+ *     (YEAR/MONTH/DAY/…), and the cast-target type names
+ *     (TIMESTAMP/DATE/NUMBER/STRING/BOOLEAN/JSON).
+ *   - `!` is the cast operator (`epoch_ms!timestamp(x)`); it glues to both
+ *     sides like `.` does.
+ *   - Empty `{}` collapses inline (`extend {}`, not `extend {\n}`).
+ *   - `import {a, b, c} from 'x'` formats as a flat list when it fits on the
+ *     line; otherwise one item per line at +1 indent.
+ *   - `view:` definitions in a block body always have a blank line before
+ *     each one (after the first), even when no blank was in the source. The
+ *     same-kind-no-blank rule still applies to other statement kinds.
+ *   - `{...}` bodies that contain more than one section statement never
+ *     collapse onto a single line, even when they would fit. Reading two
+ *     `group_by:` clauses jammed on one line is hostile.
+ *   - Single is-item section lists keep the keyword and item on the same
+ *     line (`nest: name is { … }`), so the body wraps naturally instead of
+ *     forcing a `nest:\n  name is {` opener split.
+ *   - join_one / join_many / join_cross multi-item lists always wrap one
+ *     item per line — items use `with`/`on` instead of `is` but are
+ *     structurally is-like.
+ *   - Trailing comments between the last item of a section list and the
+ *     enclosing `}` are emitted at the section's inner indent, so they
+ *     stay associated with the section the user wrote them in.
  *
  * Adding a new section-statement
  * ------------------------------

package/dist/lang/prettify/leaf.js

@@ -127,6 +127,18 @@ function hasCommentsInRange(f, fromIdx, toIdx) {
     }
     return false;
 }
+// Index of the next non-hidden, non-EOF token strictly after `idx`, or -1.
+function nextVisibleAfter(f, idx) {
+    for (let j = idx + 1; j < f.tokens.length; j++) {
+        const t = f.tokens[j];
+        if (t.channel === antlr4ts_1.Token.HIDDEN_CHANNEL)
+            continue;
+        if (t.type === antlr4ts_1.Token.EOF)
+            return -1;
+        return j;
+    }
+    return -1;
+}
 // Does the paren-pair at [openIdx, closeIdx] have any COMMA at its own depth?
 // (Used to distinguish "function call with multiple args" from "single-arg
 // call" / "empty parens".)
@@ -190,6 +202,21 @@ function emitVisibleToken(f, t, idx) {
     if (t.type === tokens_1.L.OCURLY) {
         f.o.space();
         f.o.text('{');
+        // Empty `{}`: peek the next visible token. If it's the matching close
+        // AND nothing hidden sits between them (no comments to preserve), emit
+        // inline so we get `extend {}` not `extend {\n}`. With a comment in the
+        // gap (`extend { /* keep */ }`), fall through to the wrapping form so
+        // the leaf walker's comment placement runs.
+        const nextVisible = nextVisibleAfter(f, idx);
+        if (nextVisible !== -1 &&
+            f.tokens[nextVisible].type === tokens_1.L.CCURLY &&
+            !hasCommentsInRange(f, idx + 1, nextVisible - 1)) {
+            f.o.text('}');
+            if (f.o.indent === 0)
+                f.needBlank = true;
+            note(f, tokens_1.L.CCURLY, nextVisible, f.tokens[nextVisible]);
+            return;
+        }
         f.o.indent++;
         f.o.nl();
         note(f, t.type, idx, t);

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

@@ -1,5 +1,5 @@
 import type { ParserRuleContext } from 'antlr4ts';
-export type ItemKind = 'fieldEntry' | 'nestEntry' | 'fieldDef' | 'fieldName' | 'collectionMember' | 'orderBySpec' | 'fieldExpr';
+export type ItemKind = 'fieldEntry' | 'nestEntry' | 'fieldDef' | 'fieldName' | 'collectionMember' | 'orderBySpec' | 'fieldExpr' | 'joinDef' | 'includeField' | 'indexElement';
 export interface SectionRule {
     ctxClass: new (...args: never[]) => ParserRuleContext;
     keywordTypes: number[];

package/dist/lang/prettify/rules.js

@@ -79,6 +79,14 @@ exports.SECTION_STATEMENT_RULES = [
     rule(parser.OrderByStatementContext, [tokens_1.L.ORDER_BY], c => c.ordering(), 'orderBySpec'),
     rule(parser.WhereStatementContext, [tokens_1.L.WHERE], c => c.filterClauseList(), 'fieldExpr'),
     rule(parser.HavingStatementContext, [tokens_1.L.HAVING], c => c.filterClauseList(), 'fieldExpr'),
+    rule(parser.DefJoinOneContext, [tokens_1.L.JOIN_ONE], c => c.joinList(), 'joinDef'),
+    rule(parser.DefJoinManyContext, [tokens_1.L.JOIN_MANY], c => c.joinList(), 'joinDef'),
+    rule(parser.DefJoinCrossContext, [tokens_1.L.JOIN_CROSS], c => c.joinList(), 'joinDef'),
+    // include block items: `public: a, b`, `internal: x, y, z`. The keyword
+    // (PUBLIC/PRIVATE/INTERNAL) lives one level down inside accessLabelProp;
+    // findKeyword in ./sections handles that nested case.
+    rule(parser.IncludeItemContext, [tokens_1.L.PUBLIC, tokens_1.L.PRIVATE, tokens_1.L.INTERNAL], c => c.includeList(), 'includeField'),
+    rule(parser.IndexStatementContext, [tokens_1.L.INDEX], c => c.indexFields(), 'indexElement'),
 ];
 // Coarse statement-kind labels for the same-kind-no-blank rule in block
 // bodies. Different kinds preserve a single user-supplied blank line.

package/dist/lang/prettify/sections.js

@@ -13,11 +13,21 @@
  *
  * formatSectionList rule (locked in with the user):
  *   - All bare items + total fits ≤ LINE_BUDGET → inline `kw: a, b, c`.
- *   - Single item that fits (even if it has `is`) → inline.
+ *   - Single item that fits (even if it has `is`) → inline. Items containing
+ *     a `{...}` body with more than one section statement are excluded —
+ *     view bodies don't read on one line regardless of length.
+ *   - Single is-item that doesn't fit inline → keep keyword and item on the
+ *     same line (`nest: name is { …wrapped body… }`); the body's `{...}`
+ *     wraps internally. Annotated items still take the keyword-on-own-line
+ *     form so the annotation lands above its item.
  *   - Otherwise → wrapped: keyword on its own line; items at +1 indent;
  *       bare items flow-fill ≤ LINE_BUDGET, comma-separated intra-line,
  *       no trailing commas; `is` items each on own line; annotated items
  *       each on own line, annotation on the line above.
+ *
+ * After the last item, trailing comments that sit between the section and
+ * the enclosing `}` are also emitted at the inner indent — they belong to
+ * the section the user just wrote, not the parent block.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -70,7 +80,9 @@ function formatSectionStatement(f, stmt, rule) {
     }
     for (let i = 0; i < stmt.childCount; i++) {
         const c = stmt.getChild(i);
-        if (c instanceof tree_1.TerminalNode && c.symbol === keywordTok) {
+        const isKeywordChild = (c instanceof tree_1.TerminalNode && c.symbol === keywordTok) ||
+            (c instanceof antlr4ts_1.ParserRuleContext && childContainsToken(c, keywordTok));
+        if (isKeywordChild) {
             (0, leaf_1.flushHiddenBefore)(f, keywordTok.tokenIndex);
             if (f.o.indent > 0)
                 f.o.nl();
@@ -83,18 +95,39 @@ function formatSectionStatement(f, stmt, rule) {
         if (c === listCtx) {
             const items = listItems(listCtx, rule.itemKind);
             if (items.length > 0)
-                formatSectionList(f, items);
+                formatSectionList(f, items, rule.itemKind);
             continue;
         }
         f.format(c);
     }
 }
+function childContainsToken(node, tok) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.getChild(i);
+        if (c instanceof tree_1.TerminalNode && c.symbol === tok)
+            return true;
+    }
+    return false;
+}
 function findKeyword(node, types) {
+    // Direct terminal children — fast path, the common case.
     for (let i = 0; i < node.childCount; i++) {
         const c = node.getChild(i);
         if (c instanceof tree_1.TerminalNode && types.includes(c.symbol.type))
             return c.symbol;
     }
+    // Fallback: descend one level. Some rules wrap the keyword in a small
+    // nested rule (e.g. includeItem → accessLabelProp → INTERNAL).
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.getChild(i);
+        if (c instanceof antlr4ts_1.ParserRuleContext) {
+            for (let j = 0; j < c.childCount; j++) {
+                const g = c.getChild(j);
+                if (g instanceof tree_1.TerminalNode && types.includes(g.symbol.type))
+                    return g.symbol;
+            }
+        }
+    }
     return undefined;
 }
 function listItems(listCtx, itemKind) {
@@ -117,6 +150,12 @@ function listItems(listCtx, itemKind) {
                 return c instanceof parser.OrderBySpecContext;
             case 'fieldExpr':
                 return c instanceof parser.FieldExprContext;
+            case 'joinDef':
+                return c instanceof parser.JoinDefContext;
+            case 'includeField':
+                return c instanceof parser.IncludeFieldContext;
+            case 'indexElement':
+                return c instanceof parser.IndexElementContext;
         }
     };
     const out = [];
@@ -127,8 +166,10 @@ function listItems(listCtx, itemKind) {
     }
     return out;
 }
-function classifyItem(f, ctx) {
-    let hasIs = false;
+function classifyItem(f, ctx, itemKind) {
+    // joinDef items always wrap onto their own line. They use `with` / `on`
+    // instead of `is`, but they're structurally one-per-line like is-items.
+    let hasIs = itemKind === 'joinDef';
     let hasAnnotation = false;
     for (let i = ctx._start.tokenIndex; i <= ctx._stop.tokenIndex; i++) {
         const t = f.tokens[i];
@@ -142,17 +183,23 @@ function classifyItem(f, ctx) {
     }
     return { ctx, hasIs, hasAnnotation };
 }
-function formatSectionList(f, items) {
-    const itemInfos = items.map(it => classifyItem(f, it));
+function formatSectionList(f, items, itemKind) {
+    const itemInfos = items.map(it => classifyItem(f, it, itemKind));
     const noAnnotations = itemInfos.every(info => !info.hasAnnotation);
     const allBare = itemInfos.every(info => !info.hasIs && !info.hasAnnotation);
     const firstItem = items[0];
     const lastItem = items[items.length - 1];
     // Inline candidate: no annotations, no hidden-channel comments anywhere in
     // the items' span (renderItemInline drops them), AND either all bare or
-    // exactly one item.
+    // exactly one item. Items containing a `{...}` body with multiple inner
+    // statements are also excluded — collapsing a view body onto one line is
+    // hostile to read regardless of length.
     const itemsHaveComments = (0, leaf_1.hasCommentsInRange)(f, firstItem._start.tokenIndex, lastItem._stop.tokenIndex);
-    const inlineEligible = noAnnotations && !itemsHaveComments && (allBare || items.length === 1);
+    const itemsHaveMultiStatementBody = itemInfos.some(info => hasMultiStatementCurlyBody(f, info.ctx));
+    const inlineEligible = noAnnotations &&
+        !itemsHaveComments &&
+        !itemsHaveMultiStatementBody &&
+        (allBare || items.length === 1);
     if (inlineEligible) {
         const renderedItems = itemInfos.map(info => (0, inline_renderer_1.renderItemInline)(f, info.ctx));
         const inlineBody = renderedItems.join(', ');
@@ -164,6 +211,20 @@ function formatSectionList(f, items) {
             return;
         }
     }
+    // Single is-item that doesn't fit inline: keep the keyword on the same
+    // line as the item (`nest: name is { …wrapped body… }`) instead of
+    // breaking before the name. The body's `{...}` will wrap on its own.
+    // Annotated items still need the keyword-on-own-line form so the
+    // annotation can land between them.
+    if (items.length === 1 &&
+        itemInfos[0].hasIs &&
+        !itemInfos[0].hasAnnotation &&
+        !itemsHaveComments) {
+        f.o.text(' ');
+        f.format(itemInfos[0].ctx);
+        f.lastEmittedType = lastItem._stop.type;
+        return;
+    }
     // Wrapped form. Two paths:
     //   - No comments anywhere: original flow-fill — bare items pack into lines
     //     at LINE_BUDGET, `is`/annotated items each get their own line.
@@ -230,14 +291,56 @@ function formatSectionList(f, items) {
     // lastEmittedIdx so tail comments aren't re-emitted by the parent.
     f.lastEmittedType = lastItem._stop.type;
 }
-// After the last item of a wrapped section list, flush any trailing comments
-// on the SAME source line as the last item — those are tail comments belong-
-// ing to the last item and should emit at the section's inner indent.
-// Different-line comments are leading comments for the next statement; leave
-// them for the parent context to emit at the outer indent.
+// Does any `{...}` block inside this item contain more than one section
+// keyword (group_by:, aggregate:, where:, …) at its top level? Used to gate
+// the section-list inline form: a view body with multiple statements never
+// reads well on a single line, even when it fits. Single-statement bodies
+// like `{ where: x = 1 }` may still inline.
+function hasMultiStatementCurlyBody(f, ctx) {
+    const fromIdx = ctx._start.tokenIndex;
+    const toIdx = ctx._stop.tokenIndex;
+    for (let i = fromIdx; i <= toIdx; i++) {
+        if (f.tokens[i].type !== tokens_1.L.OCURLY)
+            continue;
+        const close = (0, tokens_1.findMatching)(f.tokens, i, tokens_1.L.OCURLY, tokens_1.L.CCURLY);
+        let count = 0;
+        let depth = 0;
+        for (let j = i + 1; j < close; j++) {
+            const t = f.tokens[j];
+            if (t.type === tokens_1.L.OCURLY || t.type === tokens_1.L.OPAREN || t.type === tokens_1.L.OBRACK) {
+                depth++;
+            }
+            else if (t.type === tokens_1.L.CCURLY ||
+                t.type === tokens_1.L.CPAREN ||
+                t.type === tokens_1.L.CBRACK) {
+                depth--;
+            }
+            else if (depth === 0 && tokens_1.SECTION_TOKENS.has(t.type)) {
+                count++;
+                if (count > 1)
+                    return true;
+            }
+        }
+        i = close;
+    }
+    return false;
+}
+// After the last item of a wrapped section list, flush trailing comments
+// belonging to the section. There are two cases:
+//
+//   1. Same-line tail: a comment on the SAME source line as the last item.
+//      Always belongs to the last item; emit at the section's inner indent.
+//
+//   2. Different-line trailing comments that sit between the last item and
+//      the closing `}` of the enclosing block (no other statement follows).
+//      These visually belong to the section the user just wrote, not the
+//      block. Emit them at the inner indent so they stay associated with
+//      the section. If a real statement follows the comments, leave them
+//      for the parent — they're leading comments for that statement.
 function flushSameLineTail(f, lastTok) {
     const lastEndLine = (0, tokens_1.endLineOf)(lastTok);
     let j = lastTok.tokenIndex + 1;
+    // Phase 1: same-line tail comments.
     while (j < f.tokens.length) {
         const t = f.tokens[j];
         if (t.channel !== antlr4ts_1.Token.HIDDEN_CHANNEL)
@@ -247,15 +350,31 @@ function flushSameLineTail(f, lastTok) {
         j++;
     }
     if (j > lastTok.tokenIndex + 1) {
-        // The wrapping loop emitted a per-item newline after the last item, but
-        // a same-line tail comment should attach to that item's line — not float
-        // on a fresh one. Drop the trailing newline so emitHiddenToken's
-        // same-line branch reattaches the comment correctly (and adds a trailing
-        // newline back for EOL comments). Without this, the comment lands on a
-        // new line, and a re-parse sees it as a different-line comment, breaking
-        // idempotence.
+        // Same-line comments: drop the wrapping loop's per-item newline so
+        // emitHiddenToken's same-line branch reattaches the comment correctly
+        // (and adds a trailing newline back for EOL comments). Otherwise a
+        // re-parse sees a different-line comment, breaking idempotence.
         f.o.trimTrailingNewlines();
         (0, leaf_1.flushHiddenBefore)(f, j);
     }
+    // Phase 2: own-line comments before the next visible token. If the next
+    // visible token is a closing `}`, the comments visually belong to this
+    // section — emit them at the inner indent. Otherwise leave them for the
+    // parent (they're leading comments for whatever follows).
+    let k = j;
+    let trailingHidden = 0;
+    while (k < f.tokens.length) {
+        const t = f.tokens[k];
+        if (t.channel !== antlr4ts_1.Token.HIDDEN_CHANNEL)
+            break;
+        trailingHidden++;
+        k++;
+    }
+    if (trailingHidden > 0 && k < f.tokens.length) {
+        const next = f.tokens[k];
+        if (next.type === tokens_1.L.CCURLY) {
+            (0, leaf_1.flushHiddenBefore)(f, k);
+        }
+    }
 }
 //# sourceMappingURL=sections.js.map

package/dist/lang/prettify/tokens.js

@@ -87,6 +87,26 @@ exports.CALL_HUG_AFTER = new Set([
     exports.L.CAST,
     exports.L.NOW,
     exports.L.LAST,
+    // Ungrouped / level-modifier function-style calls.
+    exports.L.ALL,
+    exports.L.EXCLUDE,
+    // Timeframe truncation keywords used as functions: year(x), month(x), …
+    exports.L.YEAR,
+    exports.L.QUARTER,
+    exports.L.MONTH,
+    exports.L.WEEK,
+    exports.L.DAY,
+    exports.L.HOUR,
+    exports.L.MINUTE,
+    exports.L.SECOND,
+    // Type-cast keyword names: timestamp(x), date(x), number(x), string(x), …
+    exports.L.TIMESTAMP,
+    exports.L.TIMESTAMPTZ,
+    exports.L.DATE,
+    exports.L.NUMBER,
+    exports.L.STRING,
+    exports.L.BOOLEAN,
+    exports.L.JSON,
 ]);
 // Binary operators that get spaces on both sides at the leaf level.
 // (Chain wrapping for and/or/??/+/- happens at parse-tree level — see
@@ -119,10 +139,15 @@ function leadingAction(prevType, nextType) {
         nextType === exports.L.SEMI ||
         nextType === exports.L.COLON ||
         nextType === exports.L.TRIPLECOLON ||
+        nextType === exports.L.EXCLAM ||
         nextType === exports.L.CPAREN ||
         nextType === exports.L.CBRACK) {
         return 'glue';
     }
+    // After the `!` cast operator (`epoch_ms!timestamp(x)`), the next token
+    // glues to it like the `.` operator does.
+    if (prevType === exports.L.EXCLAM)
+        return 'glue';
     if ((nextType === exports.L.OPAREN || nextType === exports.L.OBRACK) &&
         prevType !== null &&
         exports.CALL_HUG_AFTER.has(prevType)) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.386";
+export declare const MALLOY_VERSION = "0.0.388";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.386';
+exports.MALLOY_VERSION = '0.0.388';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.386",
+  "version": "0.0.388",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -51,9 +51,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.386",
-    "@malloydata/malloy-interfaces": "0.0.386",
-    "@malloydata/malloy-tag": "0.0.386",
+    "@malloydata/malloy-filter": "0.0.388",
+    "@malloydata/malloy-interfaces": "0.0.388",
+    "@malloydata/malloy-tag": "0.0.388",
     "@noble/hashes": "^1.8.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",