@malloydata/malloy 0.0.391 → 0.0.393

package/dist/lang/ast/expressions/expr-now.js

@@ -36,7 +36,6 @@ class ExprNow extends expression_def_1.ExpressionDef {
             // `now` is considered to be a constant, at least in the dialects we support today
             evalSpace: 'constant',
             value: { node: 'now', typeDef: { type: 'timestamp' } },
-            fieldUsage: [],
         };
     }
 }

package/dist/lang/ast/expressions/expr-props.d.ts

@@ -7,211 +7,211 @@ export declare class ExprProps extends ExpressionDef {
     readonly expr: ExpressionDef;
     readonly statements: FieldPropStatement[];
     elementType: string;
-    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
     constructor(expr: ExpressionDef, statements: FieldPropStatement[]);
     private getFilteredExpression;
     getExpression(fs: FieldSpace): ExprValue;
     getGroupedBys(fs: FieldSpace, expr: ExprValue, groupedBys: GroupedBy[]): {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "string";
         bucketFilter?: string;
         bucketOther?: string;
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "date";
-        timeframe?: import("../../../model/malloy_types").DateUnit;
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        timeframe?: import("../../..").DateUnit;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "timestamp";
-        timeframe?: import("../../../model/malloy_types").TimestampUnit;
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        timeframe?: import("../../..").TimestampUnit;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "timestamptz";
-        timeframe?: import("../../../model/malloy_types").TimestampUnit;
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        timeframe?: import("../../..").TimestampUnit;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "number";
         numberType?: "integer" | "float" | "bigint";
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "boolean";
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "json";
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "sql native";
         rawType?: string;
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "error";
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "array";
-        elementTypeDef: Exclude<import("../../../model/malloy_types").AtomicTypeDef, import("../../../model/malloy_types").RecordTypeDef>;
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        elementTypeDef: Exclude<import("../../..").AtomicTypeDef, import("../../..").RecordTypeDef>;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "record";
-        fields: import("../../../model/malloy_types").FieldDef[];
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        fields: import("../../..").FieldDef[];
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "array";
-        elementTypeDef: import("../../../model/malloy_types").RecordElementTypeDef;
-        fields: import("../../../model/malloy_types").FieldDef[];
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        elementTypeDef: import("../../../model").RecordElementTypeDef;
+        fields: import("../../..").FieldDef[];
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
-        type: import("../../../model/malloy_types").NonAtomicType;
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
+        type: import("../../../model").NonAtomicType;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "turtle";
-        pipeline: import("../../../model/malloy_types").PipeSegment[];
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        pipeline: import("../../..").PipeSegment[];
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "date";
         timeframe?: "day" | "week" | "month" | "quarter" | "year" | undefined;
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "timestamp";
-        timeframe?: import("../../../model/malloy_types").TimestampUnit;
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
+        timeframe?: import("../../..").TimestampUnit;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
         morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+            [x: string]: import("../../..").Expr;
         };
     } | {
-        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "timestamptz";
-        timeframe?: import("../../../model/malloy_types").TimestampUnit;
-        expressionType: import("../../../model/malloy_types").ExpressionType;
-        evalSpace: import("../../../model/malloy_types").EvalSpace;
-        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
-        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
-        value: import("../../../model/malloy_types").Expr;
-        morphic?: {
-            [x: string]: import("../../../model/malloy_types").Expr;
+        timeframe?: import("../../..").TimestampUnit;
+        expressionType: import("../../..").ExpressionType;
+        evalSpace: import("../../../model").EvalSpace;
+        refSummary?: import("../../../model").RefSummary;
+        ungroupings?: import("../../../model").AggregateUngrouping[];
+        value: import("../../..").Expr;
+        morphic?: {
+            [x: string]: import("../../..").Expr;
         };
     };
 }

package/dist/lang/ast/expressions/expr-props.js

@@ -57,6 +57,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprProps = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
+const composite_source_utils_1 = require("../../composite-source-utils");
 const ast_utils_1 = require("../ast-utils");
 const TDU = __importStar(require("../typedesc-utils"));
 const function_ordering_1 = require("./function-ordering");
@@ -65,7 +66,6 @@ const partition_by_1 = require("./partition_by");
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const expr_func_1 = require("./expr-func");
-const composite_source_utils_1 = require("../../composite-source-utils");
 const grouped_by_1 = require("./grouped_by");
 class ExprProps extends expression_def_1.ExpressionDef {
     constructor(expr, statements) {
@@ -93,7 +93,7 @@ class ExprProps extends expression_def_1.ExpressionDef {
             if (this.typeCheck(this.expr, { ...expr, expressionType: 'scalar' })) {
                 return {
                     ...expr,
-                    fieldUsage: (0, composite_source_utils_1.mergeFieldUsage)(expr.fieldUsage, ...filterList.map(f => { var _a; return (_a = f.fieldUsage) !== null && _a !== void 0 ? _a : []; })),
+                    refSummary: (0, composite_source_utils_1.mergeRefSummaries)(expr.refSummary, ...filterList.map(f => f.refSummary)),
                     value: {
                         node: 'filteredExpr',
                         kids: { e: expr.value, filterList },

package/dist/lang/ast/expressions/expr-ungroup.d.ts

@@ -5,7 +5,7 @@ export declare class ExprUngroup extends ExpressionDef {
     readonly control: 'all' | 'exclude';
     readonly expr: ExpressionDef;
     readonly fields: FieldName[];
-    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
     elementType: string;
     constructor(control: 'all' | 'exclude', expr: ExpressionDef, fields: FieldName[]);
     getExpression(fs: FieldSpace): ExprValue;

package/dist/lang/ast/expressions/expr-ungroup.js

@@ -117,18 +117,18 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
                 }
                 ungroup.fields = dstFields;
             }
-            const fieldUsage = exprVal.fieldUsage;
+            const fieldUsage = (0, malloy_types_1.fieldUsageFrom)(exprVal.refSummary);
             return {
                 ...TDU.atomicDef(exprVal),
                 expressionType: 'ungrouped_aggregate',
                 value: ungroup,
                 evalSpace: 'output',
-                fieldUsage,
+                refSummary: exprVal.refSummary,
                 ungroupings: [
                     {
                         requiresGroupBy: (_a = exprVal.requiresGroupBy) !== null && _a !== void 0 ? _a : [],
-                        fieldUsage: fieldUsage !== null && fieldUsage !== void 0 ? fieldUsage : [],
-                        ungroupedFields: isExclude ? ungroupFields !== null && ungroupFields !== void 0 ? ungroupFields : [] : '*',
+                        fieldUsage,
+                        ungroupedFields: isExclude ? (ungroupFields !== null && ungroupFields !== void 0 ? ungroupFields : []) : '*',
                         path: [],
                         exclude: isExclude,
                         refFields: ungroup.fields,

package/dist/lang/ast/expressions/for-range.d.ts

@@ -8,7 +8,7 @@ export declare class ForRange extends ExpressionDef {
     readonly duration: ExpressionDef;
     readonly timeframe: Timeframe;
     elementType: string;
-    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
     constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
     apply(fs: FieldSpace, op: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;

package/dist/lang/ast/expressions/function-ordering.d.ts

@@ -2,7 +2,7 @@ import type { FieldUsage, FunctionOrderBy as ModelFunctionOrderBy } from '../../
 import type { ExpressionDef } from '../types/expression-def';
 import type { FieldSpace } from '../types/field-space';
 import { ListOf, MalloyElement } from '../types/malloy-element';
-type FieldUsageSummary = FieldUsage[] | undefined;
+type FieldUsageSummary = FieldUsage | undefined;
 export declare class FunctionOrderBy extends MalloyElement {
     readonly field?: ExpressionDef | undefined;
     readonly dir?: "asc" | "desc" | undefined;

package/dist/lang/ast/expressions/function-ordering.js

@@ -50,7 +50,7 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
             };
         }
         const expr = this.field.getExpression(fs);
-        fieldUsage = expr.fieldUsage;
+        fieldUsage = (0, malloy_types_1.fieldUsageFrom)(expr.refSummary);
         if ((0, malloy_types_1.expressionIsAggregate)(expr.expressionType)) {
             // Aggregates are okay
         }
@@ -77,7 +77,7 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
         const dir = this.dir || 'asc';
         if (this.field) {
             const expr = this.field.getExpression(fs);
-            fieldUsage = expr.fieldUsage;
+            fieldUsage = (0, malloy_types_1.fieldUsageFrom)(expr.refSummary);
             if (!(0, malloy_types_1.expressionIsScalar)(expr.expressionType)) {
                 this.field.logError('aggregate-order-by-not-scalar', 'aggregate `order_by` must be scalar');
             }

package/dist/lang/ast/expressions/time-literal.d.ts

@@ -24,11 +24,11 @@ export declare abstract class TimeLiteral extends ExpressionDef {
     protected makeLiteral(fs: FieldSpace, val: string, typ: TemporalFieldType, units: TimestampUnit | undefined): TimeLiteralExpr;
     protected makeValue(fs: FieldSpace, val: string, dataType: TemporalFieldType): TimeResult;
     getStableLiteral(): Malloy.LiteralValue;
-    getValue(): (import("../../../model/malloy_types").DateTypeDef & import("../../../model/malloy_types").TypeInfo & import("../types/expr-result").WithValue & {
+    getValue(): (import("../../../model").DateTypeDef & import("../../../model").TypeInfo & import("../types/expr-result").WithValue & {
         timeframe?: TimestampUnit;
-    }) | (import("../../../model/malloy_types").TimestampTypeDef & import("../../../model/malloy_types").TypeInfo & import("../types/expr-result").WithValue & {
+    }) | (import("../../../model").TimestampTypeDef & import("../../../model").TypeInfo & import("../types/expr-result").WithValue & {
         timeframe?: TimestampUnit;
-    }) | (import("../../../model/malloy_types").TimestamptzTypeDef & import("../../../model/malloy_types").TypeInfo & import("../types/expr-result").WithValue & {
+    }) | (import("../../../model").TimestamptzTypeDef & import("../../../model").TypeInfo & import("../types/expr-result").WithValue & {
         timeframe?: TimestampUnit;
     });
     getExpression(fs: FieldSpace): ExprValue;

package/dist/lang/ast/field-space/include-utils.js

@@ -105,7 +105,7 @@ function processIncludeList(includeItems, from) {
         if (item instanceof include_item_1.IncludeAccessItem) {
             for (const f of item.fields) {
                 const joinPath = f.name instanceof field_references_1.WildcardFieldReference
-                    ? (_b = (_a = f.name.joinPath) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : []
+                    ? ((_b = (_a = f.name.joinPath) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : [])
                     : f.name.path.slice(0, -1);
                 const joinState = getOrCreateIncludeStateForJoin(joinPath, state, from, f);
                 checkParents(state, joinPath, from, f, item.kind);
@@ -179,7 +179,7 @@ function processIncludeList(includeItems, from) {
         else if (item instanceof include_item_1.IncludeExceptItem) {
             for (const f of item.fields) {
                 const joinPath = f instanceof field_references_1.WildcardFieldReference
-                    ? (_p = (_o = f.joinPath) === null || _o === void 0 ? void 0 : _o.path) !== null && _p !== void 0 ? _p : []
+                    ? ((_p = (_o = f.joinPath) === null || _o === void 0 ? void 0 : _o.path) !== null && _p !== void 0 ? _p : [])
                     : f.path.slice(0, -1);
                 const joinState = getOrCreateIncludeStateForJoin(joinPath, state, from, f);
                 checkParents(state, joinPath, from, f, item.kind);

package/dist/lang/ast/field-space/index-field-space.js

@@ -66,39 +66,34 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
         };
     }
     getPipeSegment(refineIndex) {
-        var _a;
         if (refineIndex) {
             this.logError('refinement-of-index-segment', 'index query operations cannot be refined');
             return error_factory_1.ErrorFactory.indexSegment;
         }
-        let fieldUsage = (0, composite_source_utils_1.emptyFieldUsage)();
         const indexFields = [];
+        let refSummary = undefined;
         for (const [name, field] of this.entries()) {
-            if (field instanceof space_field_1.SpaceField) {
-                let nextFieldUsage = undefined;
-                const wild = this.expandedWild.get(name);
-                if (wild) {
-                    indexFields.push({ type: 'fieldref', path: wild.path, at: wild.at });
-                    fieldUsage.push({ path: wild.path });
-                    nextFieldUsage = wild.entry.typeDesc().fieldUsage;
+            if (!(field instanceof space_field_1.SpaceField))
+                continue;
+            const wild = this.expandedWild.get(name);
+            if (wild) {
+                indexFields.push({ type: 'fieldref', path: wild.path, at: wild.at });
+                refSummary = (0, composite_source_utils_1.mergeRefSummaries)(refSummary, { fieldUsage: [{ path: wild.path }] }, wild.entry.typeDesc().refSummary);
+            }
+            else if (field instanceof reference_field_1.ReferenceField) {
+                // attempt to cause a type check
+                const fieldRef = field.fieldRef;
+                const check = fieldRef.getField(this.exprSpace);
+                if (check.error) {
+                    fieldRef.logError(check.error.code, check.error.message);
                 }
-                else if (field instanceof reference_field_1.ReferenceField) {
-                    // attempt to cause a type check
-                    const fieldRef = field.fieldRef;
-                    const check = fieldRef.getField(this.exprSpace);
-                    if (check.error) {
-                        fieldRef.logError(check.error.code, check.error.message);
-                    }
-                    else {
-                        indexFields.push(fieldRef.refToField);
-                        nextFieldUsage = check.found.typeDesc().fieldUsage;
-                        fieldUsage.push({ path: fieldRef.path });
-                    }
+                else {
+                    indexFields.push(fieldRef.refToField);
+                    refSummary = (0, composite_source_utils_1.mergeRefSummaries)(refSummary, { fieldUsage: [{ path: fieldRef.path }] }, check.found.typeDesc().refSummary);
                 }
-                fieldUsage = (_a = (0, composite_source_utils_1.mergeFieldUsage)(fieldUsage, nextFieldUsage)) !== null && _a !== void 0 ? _a : [];
             }
         }
-        this._fieldUsage = fieldUsage;
+        this.refSummary = refSummary;
         const outputStruct = this.structDef();
         return { type: 'index', indexFields, outputStruct };
     }

package/dist/lang/ast/field-space/passthrough-space.d.ts

@@ -16,7 +16,7 @@ export declare class PassthroughSpace implements FieldSpace {
     dialectObj(): Dialect | undefined;
     isQueryFieldSpace(): this is QueryFieldSpace;
     outputSpace(): import("./query-spaces").QueryOperationSpace;
-    inputSpace(): import("../types/field-space").SourceFieldSpace;
+    inputSpace(): import("..").SourceFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;
     connectionName(): string;
 }

package/dist/lang/ast/field-space/query-spaces.d.ts

@@ -43,8 +43,12 @@ export declare abstract class QueryOperationSpace extends RefinedSpace implement
         name: string;
         field: SpaceField;
     })[];
-    _fieldUsage: model.FieldUsage[] | undefined;
-    get fieldUsage(): model.FieldUsage[];
+    private _refSummary;
+    private _refSummaryComputed;
+    get refSummary(): model.RefSummary | undefined;
+    protected set refSummary(rs: model.RefSummary | undefined);
+    get fieldUsage(): model.FieldUsage;
+    get givenUsage(): model.GivenUsage;
     constructor(queryInputSpace: SourceFieldSpace, refineThis: model.PipeSegment | undefined, nestParent: QueryOperationSpace | undefined, astEl: MalloyElement);
     abstract addRefineFromFields(refineThis: model.PipeSegment): void;
     logError<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): T;