@malloydata/malloy 0.0.433 → 0.0.434

package/dist/model/join_instance.js

@@ -30,6 +30,14 @@ class JoinInstance {
             }, this.queryStruct));
         }
     }
+    // A filtered join whose own joins go inside its subquery, so that the
+    // subquery has to project them back out for anything outside to name them.
+    isSubquery() {
+        return (this.children.length > 0 &&
+            this.joinFilterConditions !== undefined &&
+            (0, malloy_types_1.isJoinedSource)(this.queryStruct.structDef) &&
+            this.queryStruct.dialect.supportsComplexFilteredSources);
+    }
     parentRelationship() {
         if (this.queryStruct.parent === undefined) {
             return 'root';
@@ -64,7 +72,7 @@ class JoinInstance {
     }
     // postgres unnest needs to know the names of the physical fields.
     getDialectFieldList() {
-        return (0, utils_1.getDialectFieldList)(this.queryStruct.structDef);
+        return (0, utils_1.getDialectFieldList)(this.queryStruct.structDef, this.queryStruct.dialect);
     }
 }
 exports.JoinInstance = JoinInstance;

package/dist/model/query_query.d.ts

@@ -34,6 +34,7 @@ export declare class QueryQuery extends QueryField {
     maxDepth: number;
     maxGroupSet: number;
     rootResult: FieldInstanceResultRoot;
+    private packedColumns;
     resultStage: string | undefined;
     stageWriter: StageWriter | undefined;
     isJoinedSubquery: boolean;
@@ -90,6 +91,30 @@ export declare class QueryQuery extends QueryField {
         sql?: string;
     };
     generateSQLJoinBlock(stageWriter: StageWriter, ji: JoinInstance, depth: number): string;
+    /**
+     * Which column of which join a reference needs, or undefined when it needs
+     * none.  Walking `path` from `from`, the answer is the member of the
+     * innermost join along it -- a record is kept whole, since a reference into
+     * one is a reference to the column holding it.
+     *
+     * Two kinds of path need no column.  One ending at a computed field
+     * contributes that field's name, which is no column of the source; the
+     * columns the computation reads arrive as references of their own.  And a
+     * `having:` or `calculate:` names an *output* field, so its path is rooted
+     * in the query's output rather than its source and need not resolve here at
+     * all.  An output name which happens to match a source column resolves as
+     * though it were one, which costs nothing: a query's own source is never
+     * packed, only the joins beneath a filtered one.
+     */
+    private packedColumnFor;
+    /**
+     * Which columns of each join have to survive being packed into a struct:
+     * every column the segment's field usage names, plus each join's primary
+     * key, which the compiler reaches for as a distinct key without any
+     * expression in the query naming it.
+     */
+    private packedColumnsByJoin;
+    private joinProjectionFieldList;
     generateSQLPassthroughKeys(qs: QueryStruct): string;
     generateSQLJoins(stageWriter: StageWriter): string;
     /**

package/dist/model/query_query.js

@@ -39,9 +39,9 @@ function groupByPositions(columns) {
     return columns.flatMap((c, i) => (c.isDimension ? [i + 1] : []));
 }
 function pushDialectField(dl, f) {
-    const { sqlExpression, sqlOutputName, rawName } = f;
+    const { sqlExpression, rawName } = f;
     if ((0, malloy_types_1.isAtomic)(f.fieldDef)) {
-        dl.push({ typeDef: f.fieldDef, sqlExpression, sqlOutputName, rawName });
+        dl.push({ typeDef: f.fieldDef, sqlExpression, rawName });
     }
 }
 /** Query builder object. */
@@ -539,13 +539,23 @@ class QueryQuery extends query_node_1.QueryField {
             case 'virtual': {
                 const virtualMap = (_a = qs.prepareResultOptions) === null || _a === void 0 ? void 0 : _a.virtualMap;
                 const tablePath = (_b = virtualMap === null || virtualMap === void 0 ? void 0 : virtualMap.get(qs.structDef.connection)) === null || _b === void 0 ? void 0 : _b.get(qs.structDef.name);
-                if (!tablePath) {
+                if (tablePath === undefined) {
                     throw new malloy_compile_error_1.MalloyCompileError(`No virtual-map entry for virtual source '${qs.structDef.name}' ` +
                         `on connection '${qs.structDef.connection}'. ` +
-                        'Add a virtual-map entry via the `virtualMap` runtime option.', 'runtime-virtual-map-missing', qs.structDef.location);
+                        'Supply the entry in `virtualMap` when compiling or running the model.', 'runtime-virtual-map-missing', qs.structDef.location);
+                }
+                // Check the binding immediately before SQL substitution, using the
+                // executing query's dialect. Other entries in the map may be unused.
+                const dialect = this.parent.dialect;
+                const checked = dialect.sqlValidateTableName(tablePath);
+                if (!checked.ok || checked.canonical !== tablePath) {
+                    const reason = checked.ok
+                        ? `use the canonical path ${checked.canonical}`
+                        : checked.error;
+                    throw new malloy_compile_error_1.MalloyCompileError(`virtualMap entry '${qs.structDef.connection}.${qs.structDef.name}' ` +
+                        `has table path ${JSON.stringify(tablePath)}, which is not a ` +
+                        `canonical table path for ${dialect.name}: ${reason}`, 'runtime-virtual-map-invalid', qs.structDef.location);
                 }
-                // virtualMap entries are application-supplied — assumed already
-                // canonical SQL.
                 return tablePath;
             }
             case 'composite':
@@ -676,9 +686,7 @@ class QueryQuery extends query_node_1.QueryField {
                     return tempInstance.generateExpression();
                 });
             }
-            if (ji.children.length === 0 ||
-                conditions === undefined ||
-                !this.parent.dialect.supportsComplexFilteredSources) {
+            if (!ji.isSubquery()) {
                 // LTNOTE: need a check here to see the children's where: conditions are local
                 //  to the source and not to any of it's joined children.
                 //  In Presto, we're going to get a SQL error if in this case
@@ -700,9 +708,27 @@ class QueryQuery extends query_node_1.QueryField {
             else {
                 let select = `SELECT ${ji.alias}.*`;
                 let joins = '';
+                // Every join below this one lives inside the subquery, so every one of
+                // them has to be projected out of it, not just the direct children.
+                // A child which became a subquery of its own has already flattened its
+                // whole subtree into columns, so everything under it is read from that
+                // child rather than packed a second time.
+                const projectJoin = (j, from) => {
+                    const fieldList = this.joinProjectionFieldList(j);
+                    if (fieldList.length > 0) {
+                        select +=
+                            from === undefined
+                                ? `, ${this.parent.dialect.sqlSelectAliasAsStruct(j.alias, fieldList)} AS ${j.alias}`
+                                : `, ${from}.${j.alias} AS ${j.alias}`;
+                    }
+                    const readFrom = from !== null && from !== void 0 ? from : (j.isSubquery() ? j.alias : undefined);
+                    for (const below of j.children) {
+                        projectJoin(below, readFrom);
+                    }
+                };
                 for (const childJoin of ji.children) {
                     joins += this.generateSQLJoinBlock(stageWriter, childJoin, depth + 1);
-                    select += `, ${this.parent.dialect.sqlSelectAliasAsStruct(childJoin.alias, (0, utils_1.getDialectFieldList)(childJoin.queryStruct.structDef))} AS ${childJoin.alias}`;
+                    projectJoin(childJoin, undefined);
                 }
                 select += `\nFROM ${structSQL} AS ${ji.alias}\n${joins}\nWHERE ${conditions === null || conditions === void 0 ? void 0 : conditions.join(' AND ')}\n`;
                 s += `${matrixOperation} JOIN (\n${(0, utils_1.indent)(select)}) AS ${ji.alias}\n  ON ${onCondition}\n`;
@@ -746,6 +772,111 @@ class QueryQuery extends query_node_1.QueryField {
         }
         return s;
     }
+    /**
+     * Which column of which join a reference needs, or undefined when it needs
+     * none.  Walking `path` from `from`, the answer is the member of the
+     * innermost join along it -- a record is kept whole, since a reference into
+     * one is a reference to the column holding it.
+     *
+     * Two kinds of path need no column.  One ending at a computed field
+     * contributes that field's name, which is no column of the source; the
+     * columns the computation reads arrive as references of their own.  And a
+     * `having:` or `calculate:` names an *output* field, so its path is rooted
+     * in the query's output rather than its source and need not resolve here at
+     * all.  An output name which happens to match a source column resolves as
+     * though it were one, which costs nothing: a query's own source is never
+     * packed, only the joins beneath a filtered one.
+     */
+    packedColumnFor(from, path) {
+        let struct = from;
+        let alias = struct.getIdentifier();
+        let column = undefined;
+        for (const name of path) {
+            const child = struct.getChildByName(name);
+            if (child === undefined)
+                return undefined;
+            if (!(child instanceof query_node_1.QueryFieldStruct)) {
+                column !== null && column !== void 0 ? column : (column = name);
+                break;
+            }
+            struct = child.queryStruct;
+            if (struct.getJoinableParent() === struct) {
+                // A join: what the path named above it says nothing about what this
+                // one has to pack.
+                alias = struct.getIdentifier();
+                column = undefined;
+            }
+            else {
+                column !== null && column !== void 0 ? column : (column = name);
+            }
+        }
+        return column === undefined ? undefined : [alias, column];
+    }
+    /**
+     * Which columns of each join have to survive being packed into a struct:
+     * every column the segment's field usage names, plus each join's primary
+     * key, which the compiler reaches for as a distinct key without any
+     * expression in the query naming it.
+     */
+    packedColumnsByJoin() {
+        var _a;
+        if (this.packedColumns === undefined) {
+            const packed = new Map();
+            const needed = (found) => {
+                if (found === undefined)
+                    return;
+                const [alias, column] = found;
+                const columns = packed.get(alias);
+                if (columns) {
+                    columns.add(column);
+                }
+                else {
+                    packed.set(alias, new Set([column]));
+                }
+            };
+            const usage = (0, malloy_types_1.isRawSegment)(this.firstSegment)
+                ? []
+                : ((_a = this.firstSegment.expandedFieldUsage) !== null && _a !== void 0 ? _a : []);
+            for (const { path } of usage) {
+                needed(this.packedColumnFor(this.parent, path));
+            }
+            // What a primary key needs is what it reads: a computed key's name is
+            // not a column, and the columns its expression reads are named nowhere
+            // else in the query.
+            for (const ji of this.rootResult.joins.values()) {
+                const primaryKey = ji.queryStruct.primaryKey();
+                if (primaryKey === undefined)
+                    continue;
+                const keyDef = primaryKey.fieldDef;
+                if ((0, malloy_types_1.hasExpression)(keyDef)) {
+                    for (const { path } of (0, malloy_types_1.fieldUsageFrom)(keyDef.refSummary)) {
+                        needed(this.packedColumnFor(ji.queryStruct, path));
+                    }
+                }
+                else {
+                    needed(this.packedColumnFor(ji.queryStruct, [(0, malloy_types_1.activeName)(keyDef)]));
+                }
+            }
+            this.packedColumns = packed;
+        }
+        return this.packedColumns;
+    }
+    // What a join contributes to the SELECT of a filtered join's subquery: every
+    // column named outside the subquery, and the generated __distinct_key when
+    // the join needed one.
+    joinProjectionFieldList(ji) {
+        const packed = this.packedColumnsByJoin().get(ji.alias);
+        const dialect = ji.queryStruct.dialect;
+        const fieldList = (0, utils_1.getDialectFieldList)(ji.queryStruct.structDef, dialect).filter(d => packed === null || packed === void 0 ? void 0 : packed.has(d.rawName));
+        if (ji.makeUniqueKey) {
+            fieldList.push({
+                typeDef: { type: 'string' },
+                sqlExpression: dialect.sqlQuoteIdentifier('__distinct_key'),
+                rawName: '__distinct_key',
+            });
+        }
+        return fieldList;
+    }
     // BigQuery has wildcard psudo columns that are treated differently
     //  SELECT * FROM xxx doesn't include these psuedo columns but we need them so
     //  filters can get pushed down properly when generating a UNIQUE key.
@@ -1510,8 +1641,6 @@ class QueryQuery extends query_node_1.QueryField {
     buildDialectFieldList(resultStruct) {
         const dialectFieldList = [];
         for (const [name, field] of resultStruct.allFields) {
-            const sqlName = this.parent.dialect.sqlQuoteIdentifier(name);
-            //
             if (resultStruct.firstSegment.type === 'reduce' &&
                 field instanceof field_instance_1.FieldInstanceResult) {
                 const { structDef, repeatedResultType } = this.generateTurtlePipelineSQL(field, new stage_writer_1.StageWriter(true, undefined), '<nosource>');
@@ -1527,7 +1656,6 @@ class QueryQuery extends query_node_1.QueryField {
                         typeDef: multiLineNest,
                         sqlExpression: this.parent.dialect.sqlQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
                         rawName: name,
-                        sqlOutputName: sqlName,
                     });
                 }
                 else {
@@ -1541,7 +1669,6 @@ class QueryQuery extends query_node_1.QueryField {
                         typeDef: oneLineNest,
                         sqlExpression: this.parent.dialect.sqlQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
                         rawName: name,
-                        sqlOutputName: sqlName,
                     });
                 }
             }
@@ -1552,7 +1679,6 @@ class QueryQuery extends query_node_1.QueryField {
                     fieldDef: field.f.fieldDef,
                     sqlExpression: this.parent.dialect.sqlQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
                     rawName: name,
-                    sqlOutputName: sqlName,
                 });
             }
             else if (resultStruct.firstSegment.type === 'project' &&
@@ -1562,7 +1688,6 @@ class QueryQuery extends query_node_1.QueryField {
                     fieldDef: field.f.fieldDef,
                     sqlExpression: field.generateExpression(),
                     rawName: name,
-                    sqlOutputName: sqlName,
                 });
             }
         }
@@ -1684,7 +1809,7 @@ class QueryQuery extends query_node_1.QueryField {
             const inputStruct = {
                 type: 'nest_source',
                 name: '~pipe~',
-                pipeSQL: this.parent.dialect.sqlUnnestPipelineHead(repeatedResultType === 'inline_all_numbers', sourceSQLExpression, (0, utils_1.getDialectFieldList)(structDef)),
+                pipeSQL: this.parent.dialect.sqlUnnestPipelineHead(repeatedResultType === 'inline_all_numbers', sourceSQLExpression, (0, utils_1.getDialectFieldList)(structDef, this.parent.dialect)),
                 fields: structDef.fields,
                 connection: structDef.connection,
                 dialect: structDef.dialect,

package/dist/model/sql_block.d.ts

@@ -1,8 +1,8 @@
 import type { SQLSourceRequest } from '../lang/translate-response';
-import type { SQLPhraseSegment, ModelDef } from './malloy_types';
+import type { SQLPhraseSegment, ModelDef, VirtualMap } from './malloy_types';
 /**
  * The translator needs to know the output schema of an SQLSourceDef
  * this will prepare an SQL string suitable to answer that question.
  */
-export declare function getSourceRequest(select: SQLPhraseSegment[], connection: string, partialModel: ModelDef | undefined): SQLSourceRequest;
+export declare function getSourceRequest(select: SQLPhraseSegment[], connection: string, partialModel: ModelDef | undefined, virtualMap?: VirtualMap): SQLSourceRequest;
 export declare function sqlKey(connectionName: string, sql: string): string;

package/dist/model/sql_block.js

@@ -7,62 +7,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSourceRequest = getSourceRequest;
 exports.sqlKey = sqlKey;
 const query_model_1 = require("./query_model");
-const malloy_types_1 = require("./malloy_types");
+const sql_compiled_1 = require("./sql_compiled");
 const utils_1 = require("./utils");
 /**
  * The translator needs to know the output schema of an SQLSourceDef
  * this will prepare an SQL string suitable to answer that question.
  */
-function getSourceRequest(select, connection, partialModel) {
-    let queryModel = undefined;
-    let selectStr = '';
-    let parenAlready = false;
-    for (const segment of select) {
-        if ((0, malloy_types_1.isSegmentSQL)(segment)) {
-            selectStr += segment.sql;
-            parenAlready = segment.sql.match(/\(\s*$/) !== null;
-        }
-        else if ((0, malloy_types_1.isSegmentSource)(segment)) {
-            // PersistableSourceDef (sql_select or query_source)
-            let compiledSql;
-            if (segment.type === 'sql_select') {
-                compiledSql = segment.selectStr;
-            }
-            else {
-                // query_source - compile the inner query
-                if (!queryModel) {
-                    if (!partialModel) {
-                        throw new Error('Internal error: Partial model missing when compiling SQL block');
-                    }
-                    queryModel = (0, query_model_1.makeQueryModel)(partialModel);
-                }
-                compiledSql = queryModel.compileQuery(segment.query, {
-                    defaultRowLimit: undefined,
-                    isPartialQuery: true,
-                }, false).sql;
+function getSourceRequest(select, connection, partialModel, virtualMap) {
+    let queryModel;
+    const compileQuery = (query, options) => {
+        if (!queryModel) {
+            if (!partialModel) {
+                throw new Error('Internal error: Partial model missing when compiling SQL block');
             }
-            selectStr += parenAlready ? compiledSql : `(${compiledSql})`;
-            parenAlready = false;
+            queryModel = (0, query_model_1.makeQueryModel)(partialModel);
         }
-        else {
-            // Query segment
-            if (!queryModel) {
-                if (!partialModel) {
-                    throw new Error('Internal error: Partial model missing when compiling SQL block');
-                }
-                queryModel = (0, query_model_1.makeQueryModel)(partialModel);
-            }
-            const compiledSql = queryModel.compileQuery(segment, {
-                defaultRowLimit: undefined,
-                isPartialQuery: true,
-            }, false).sql;
-            selectStr += parenAlready ? compiledSql : `(${compiledSql})`;
-            parenAlready = false;
-        }
-    }
+        return queryModel.compileQuery(query, { ...options, defaultRowLimit: undefined, isPartialQuery: true }, false).sql;
+    };
     return {
         connection,
-        selectStr,
+        selectStr: (0, sql_compiled_1.expandSQLSegments)(select, { virtualMap }, compileQuery),
     };
 }
 function sqlKey(connectionName, sql) {

package/dist/model/sql_compiled.d.ts

@@ -1,4 +1,4 @@
-import type { PrepareResultOptions, SQLSourceDef, PersistableSourceDef, Query, VirtualMap } from './malloy_types';
+import type { PrepareResultOptions, SQLSourceDef, SQLPhraseSegment, PersistableSourceDef, Query, VirtualMap } from './malloy_types';
 /**
  * Callback type for compiling a Query to SQL.
  * opts is optional - omit for "full SQL" (BuildID computation),
@@ -16,6 +16,8 @@ export type CompileQueryCallback = (query: Query, opts?: PrepareResultOptions) =
  * @param compileQuery Callback to compile a Query to SQL
  */
 export declare function getCompiledSQL(src: SQLSourceDef, opts: PrepareResultOptions, compileQuery: CompileQueryCallback): string;
+/** Expand SQL text and interpolations for schema discovery or execution. */
+export declare function expandSQLSegments(segments: SQLPhraseSegment[], opts: PrepareResultOptions, compileQuery: CompileQueryCallback): string;
 /**
  * The options a BuildID's SQL is compiled under — everything the builder and
  * the compiler must both know, and nothing else.

package/dist/model/sql_compiled.js

@@ -5,6 +5,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCompiledSQL = getCompiledSQL;
+exports.expandSQLSegments = expandSQLSegments;
 exports.buildIdOptions = buildIdOptions;
 exports.persistedTableFor = persistedTableFor;
 exports.getSourceSQL = getSourceSQL;
@@ -26,12 +27,13 @@ function getCompiledSQL(src, opts, compileQuery) {
     if (!src.selectSegments || src.selectSegments.length === 0) {
         return src.selectStr;
     }
-    // Expand each segment
-    const parts = [];
-    for (const segment of src.selectSegments) {
-        parts.push(expandSegment(segment, opts, compileQuery));
-    }
-    return parts.join('');
+    return expandSQLSegments(src.selectSegments, opts, compileQuery);
+}
+/** Expand SQL text and interpolations for schema discovery or execution. */
+function expandSQLSegments(segments, opts, compileQuery) {
+    return segments
+        .map(segment => expandSegment(segment, opts, compileQuery))
+        .join('');
 }
 /**
  * Expand a single SQLPhraseSegment to SQL.

package/dist/model/stage_writer.js

@@ -51,7 +51,7 @@ class StageWriter {
         if (lastStageName === undefined) {
             throw new Error('Internal Error: no stage to combine');
         }
-        sql += dialect.sqlCreateFunctionCombineLastStage(lastStageName, (0, utils_1.getDialectFieldList)(structDef), (_a = structDef.resultMetadata) === null || _a === void 0 ? void 0 : _a.orderBy);
+        sql += dialect.sqlCreateFunctionCombineLastStage(lastStageName, (0, utils_1.getDialectFieldList)(structDef, dialect), (_a = structDef.resultMetadata) === null || _a === void 0 ? void 0 : _a.orderBy);
         const id = `${dialect.udfPrefix}${this.root().udfs.length}`;
         sql = dialect.sqlCreateFunction(id, sql);
         this.root().udfs.push(sql);
@@ -98,11 +98,11 @@ class StageWriter {
     generateCoorelatedSubQuery(dialect, structDef) {
         var _a, _b;
         if (!this.useCTE) {
-            return dialect.sqlCreateFunctionCombineLastStage(`(${this.withs[0]})`, (0, utils_1.getDialectFieldList)(structDef), (_a = structDef.resultMetadata) === null || _a === void 0 ? void 0 : _a.orderBy);
+            return dialect.sqlCreateFunctionCombineLastStage(`(${this.withs[0]})`, (0, utils_1.getDialectFieldList)(structDef, dialect), (_a = structDef.resultMetadata) === null || _a === void 0 ? void 0 : _a.orderBy);
         }
         else {
             return (this.combineStages(true).sql +
-                dialect.sqlCreateFunctionCombineLastStage(this.getName(this.withs.length - 1), (0, utils_1.getDialectFieldList)(structDef), (_b = structDef.resultMetadata) === null || _b === void 0 ? void 0 : _b.orderBy));
+                dialect.sqlCreateFunctionCombineLastStage(this.getName(this.withs.length - 1), (0, utils_1.getDialectFieldList)(structDef, dialect), (_b = structDef.resultMetadata) === null || _b === void 0 ? void 0 : _b.orderBy));
         }
     }
 }

package/dist/model/utils.d.ts

@@ -1,5 +1,5 @@
 import type { AtomicTypeDef, Expr, FieldDef, GenericSQLExpr, GivenTypeDef, ModelDef, ModelID, StructDef } from './malloy_types';
-import type { DialectFieldList } from '../dialect';
+import type { Dialect, DialectFieldList } from '../dialect';
 /**
  * Format a typeDef as user-readable Malloy type syntax. Used in error
  * messages where we want to echo a compound type back to the user in the
@@ -58,7 +58,7 @@ export type SQLExprElement = string | Expr;
  * expression node.
  */
 export declare function composeSQLExpr(from: SQLExprElement[]): GenericSQLExpr;
-export declare function getDialectFieldList(structDef: StructDef): DialectFieldList;
+export declare function getDialectFieldList(structDef: StructDef, dialect: Dialect): DialectFieldList;
 /**
  * A little extra paranoia to save us from fields which contain the special
  * characters used to build the grouping key.

package/dist/model/utils.js

@@ -251,14 +251,13 @@ function composeSQLExpr(from) {
     }
     return ret;
 }
-function getDialectFieldList(structDef) {
+function getDialectFieldList(structDef, dialect) {
     const dialectFieldList = [];
     for (const f of structDef.fields.filter(malloy_types_1.fieldIsIntrinsic)) {
         dialectFieldList.push({
             typeDef: f,
-            sqlExpression: (0, malloy_types_1.activeName)(f),
+            sqlExpression: dialect.sqlQuoteIdentifier((0, malloy_types_1.activeName)(f)),
             rawName: (0, malloy_types_1.activeName)(f),
-            sqlOutputName: (0, malloy_types_1.activeName)(f),
         });
     }
     return dialectFieldList;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.433";
+export declare const MALLOY_VERSION = "0.0.434";

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.433';
+exports.MALLOY_VERSION = '0.0.434';
 //# sourceMappingURL=version.js.map

package/femto-config.motly

@@ -1,3 +1,5 @@
+# Config format: node ../../scripts/femto-build.js --help
+
 lexer: {
   inputs = ["src/lang/grammar/MalloyLexer.g4"]
   outputs = ["src/lang/lib/Malloy/MalloyLexer.ts"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.433",
+  "version": "0.0.434",
   "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.433",
-    "@malloydata/malloy-interfaces": "0.0.433",
-    "@malloydata/malloy-tag": "0.0.433",
+    "@malloydata/malloy-filter": "0.0.434",
+    "@malloydata/malloy-interfaces": "0.0.434",
+    "@malloydata/malloy-tag": "0.0.434",
     "@noble/hashes": "^1.8.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",