@malloydata/malloy 0.0.413 → 0.0.414

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

@@ -119,6 +119,27 @@ export declare class Explore extends Entity implements Taggable {
      *  model annotations. */
     get _modelDef(): ModelDef;
     get source(): Explore | undefined;
+    /**
+     * THIS IS A HIGHLY EXPERIMENTAL API AND MAY VANISH OR CHANGE WITHOUT NOTICE
+     *
+     * If this source was created as an unmodified reference to another source, a
+     * stable identifier of the source it refers to; undefined when this source
+     * defines its own shape. Two sources that refer to the same thing share this
+     * id, so it can be compared to tell whether two otherwise un-nameable sources
+     * are the same — even when the referenced source can't be named here.
+     */
+    get referenceSourceID(): string | undefined;
+    /**
+     * THIS IS A HIGHLY EXPERIMENTAL API AND MAY VANISH OR CHANGE WITHOUT NOTICE
+     *
+     * If this source was created as an unmodified reference to a source that is in
+     * this model's namespace (`source: a is b`, or a plain join), return that
+     * source as it appears in the namespace — read `.name` for the name it goes by
+     * here. Returns undefined when this source defines its own shape (a table,
+     * SQL, query, or modified/extended source), or when the referenced source is
+     * not in this model's namespace.
+     */
+    referencedSource(): Explore | undefined;
     isIntrinsic(): boolean;
     isExploreField(): this is ExploreField;
     /** @deprecated Use `.annotations.parseAsTag(route)`. */

package/dist/api/foundation/core.js

@@ -172,6 +172,36 @@ class Explore extends Entity {
     get source() {
         return this.sourceExplore;
     }
+    /**
+     * THIS IS A HIGHLY EXPERIMENTAL API AND MAY VANISH OR CHANGE WITHOUT NOTICE
+     *
+     * If this source was created as an unmodified reference to another source, a
+     * stable identifier of the source it refers to; undefined when this source
+     * defines its own shape. Two sources that refer to the same thing share this
+     * id, so it can be compared to tell whether two otherwise un-nameable sources
+     * are the same — even when the referenced source can't be named here.
+     */
+    get referenceSourceID() {
+        return (0, model_1.isSourceDef)(this._structDef)
+            ? this._structDef.referenceID
+            : undefined;
+    }
+    /**
+     * THIS IS A HIGHLY EXPERIMENTAL API AND MAY VANISH OR CHANGE WITHOUT NOTICE
+     *
+     * If this source was created as an unmodified reference to a source that is in
+     * this model's namespace (`source: a is b`, or a plain join), return that
+     * source as it appears in the namespace — read `.name` for the name it goes by
+     * here. Returns undefined when this source defines its own shape (a table,
+     * SQL, query, or modified/extended source), or when the referenced source is
+     * not in this model's namespace.
+     */
+    referencedSource() {
+        if (!(0, model_1.isSourceDef)(this._structDef))
+            return undefined;
+        const ref = (0, source_def_utils_1.sourceNamespaceReference)(this._ownerModelDef, this._structDef);
+        return ref ? new Explore(this._ownerModelDef, ref.source) : undefined;
+    }
     isIntrinsic() {
         if ((0, model_1.isAtomicFieldType)(this._structDef.type)) {
             return !('e' in this._structDef);

package/dist/dialect/databricks/databricks.d.ts

@@ -49,7 +49,7 @@ export declare class DatabricksDialect extends Dialect {
     sqlOrderBy(orderTerms: string[], obr?: OrderByRequest): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;
     private buildNamedStructExpression;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
     private buildArraySortComparator;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;

package/dist/dialect/databricks/databricks.js

@@ -172,8 +172,9 @@ class DatabricksDialect extends dialect_1.Dialect {
     }
     sqlAggregateTurtle(groupSet, fieldList, orderBy, limit, filterSQL) {
         const namedStruct = this.buildNamedStructExpression(fieldList);
-        const filter = filterSQL ? ` AND ${filterSQL}` : '';
-        const collectExpr = `COLLECT_LIST(${namedStruct}) FILTER (WHERE group_set=${groupSet}${filter})`;
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const filterClause = cond ? ` FILTER (WHERE ${cond})` : '';
+        const collectExpr = `COLLECT_LIST(${namedStruct})${filterClause}`;
         // COLLECT_LIST is unordered, so ordering is done post-aggregation via
         // ARRAY_SORT — the limit must slice the *ordered* array.
         const ordered = !orderBy || orderBy.length === 0

package/dist/dialect/dialect.d.ts

@@ -63,6 +63,16 @@ export type FieldReferenceType = 'table' | 'nest source' | 'array[scalar]' | 'ar
 export declare const dayIndex: number;
 export declare function inDays(units: string): boolean;
 export declare function qtz(qi: QueryInfo): string | undefined;
+/**
+ * The per-element condition for an aggregate turtle (sqlAggregateTurtle). On
+ * the normal path it gates each row by its group_set (and a projection's own
+ * `where:`). On the single-group-set fast path `groupSet` is `undefined` --
+ * there is no group_set column, every row is in the one group -- so the
+ * condition is just the `where:`, or `undefined` to include unconditionally.
+ * Callers wrap the result in whatever form the dialect uses (`FILTER (WHERE
+ * ...)`, `CASE WHEN ... THEN`, `IF(...)`).
+ */
+export declare function turtleGroupSetCondition(groupSet: number | undefined, filterSQL: string | undefined): string | undefined;
 export type OrderByClauseType = 'output_name' | 'ordinal' | 'expression';
 export type OrderByRequest = 'query' | 'turtle' | 'analytical';
 export type BooleanTypeSupport = 'supported' | 'simulated' | 'none';
@@ -176,7 +186,7 @@ export declare abstract class Dialect {
     sqlValidateTableName(input: string): ValidateTablePathResult;
     abstract sqlGroupSetTable(groupSetCount: number): string;
     abstract sqlAnyValue(groupSet: number, fieldName: string): string;
-    abstract sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
+    abstract sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
     sqlTurtleOrderByClause(orderBy: CompiledOrderBy[]): string;
     abstract sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     abstract sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;

package/dist/dialect/dialect.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dialect = exports.dayIndex = exports.EscapeStyle = exports.MAX_DECIMAL38 = exports.MIN_DECIMAL38 = exports.MAX_INT128 = exports.MIN_INT128 = exports.MAX_INT64 = exports.MIN_INT64 = exports.MAX_INT32 = exports.MIN_INT32 = void 0;
 exports.inDays = inDays;
 exports.qtz = qtz;
+exports.turtleGroupSetCondition = turtleGroupSetCondition;
 const malloy_types_1 = require("../model/malloy_types");
 const table_path_1 = require("./table-path");
 /*
@@ -61,6 +62,23 @@ function qtz(qi) {
     }
     return tz;
 }
+/**
+ * The per-element condition for an aggregate turtle (sqlAggregateTurtle). On
+ * the normal path it gates each row by its group_set (and a projection's own
+ * `where:`). On the single-group-set fast path `groupSet` is `undefined` --
+ * there is no group_set column, every row is in the one group -- so the
+ * condition is just the `where:`, or `undefined` to include unconditionally.
+ * Callers wrap the result in whatever form the dialect uses (`FILTER (WHERE
+ * ...)`, `CASE WHEN ... THEN`, `IF(...)`).
+ */
+function turtleGroupSetCondition(groupSet, filterSQL) {
+    if (groupSet === undefined) {
+        return filterSQL;
+    }
+    return filterSQL
+        ? `group_set=${groupSet} AND ${filterSQL}`
+        : `group_set=${groupSet}`;
+}
 class Dialect {
     constructor() {
         // -- we should add flags with default values from now on so as to not break

package/dist/dialect/duckdb/duckdb.d.ts

@@ -32,7 +32,7 @@ export declare class DuckDBDialect extends PostgresBase {
     sqlAnyValue(groupSet: number, fieldName: string): string;
     sqlLiteralNumber(literal: string): string;
     mapFields(fieldList: DialectFieldList): string;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/duckdb/duckdb.js

@@ -97,8 +97,9 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
             .map(f => `\n  ${f.sqlOutputName}: ${f.sqlExpression}`)
             .join(', ');
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
-        const filter = filterSQL ? ` AND ${filterSQL}` : '';
-        const list = `LIST({${fields}} ${orderByClause}) FILTER (WHERE group_set=${groupSet}${filter})`;
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const list = `LIST({${fields}} ${orderByClause})` +
+            (cond ? ` FILTER (WHERE ${cond})` : '');
         // A projection nest's limit is applied by slicing the aggregated array
         // (duckdb lists are 1-based, inclusive).
         const limited = limit !== undefined ? `(${list})[1:${limit}]` : list;

package/dist/dialect/mysql/mysql.d.ts

@@ -42,7 +42,7 @@ export declare class MySQLDialect extends Dialect {
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(_groupSet: number, fieldName: string): string;
     private mapFields;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, _limit?: number, filterSQL?: string): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, _limit?: number, filterSQL?: string): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/mysql/mysql.js

@@ -164,12 +164,16 @@ class MySQLDialect extends dialect_1.Dialect {
     sqlAggregateTurtle(groupSet, fieldList, orderBy, _limit, filterSQL) {
         const separator = ',';
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
-        const filter = filterSQL ? ` AND ${filterSQL}` : '';
-        let gc = `GROUP_CONCAT(
-      IF(group_set=${groupSet}${filter},
-        JSON_OBJECT(${this.mapFields(fieldList)})
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const json = `JSON_OBJECT(${this.mapFields(fieldList)})`;
+        const element = cond
+            ? `IF(${cond},
+        ${json}
         , null
-        )
+        )`
+            : json;
+        let gc = `GROUP_CONCAT(
+      ${element}
       ${orderByClause}
       SEPARATOR '${separator}'
     )`;

package/dist/dialect/postgres/postgres.d.ts

@@ -32,7 +32,7 @@ export declare class PostgresDialect extends PostgresBase {
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;
     mapFields(fieldList: DialectFieldList): string;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/postgres/postgres.js

@@ -100,8 +100,9 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
     sqlAggregateTurtle(groupSet, fieldList, orderBy, limit, filterSQL) {
         const fields = this.mapFields(fieldList);
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
-        const filter = filterSQL ? ` AND ${filterSQL}` : '';
-        const arrayAgg = `(ARRAY_AGG((SELECT TO_JSONB(__x) FROM (SELECT ${fields}\n  ) as __x) ${orderByClause} ) FILTER (WHERE group_set=${groupSet}${filter}))`;
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const filterClause = cond ? ` FILTER (WHERE ${cond})` : '';
+        const arrayAgg = `(ARRAY_AGG((SELECT TO_JSONB(__x) FROM (SELECT ${fields}\n  ) as __x) ${orderByClause} )${filterClause})`;
         // Slice the native ARRAY (1-based, inclusive) before TO_JSONB turns it into
         // a single jsonb value — a jsonb scalar can't be range-sliced.
         const limited = limit !== undefined ? `${arrayAgg}[1:${limit}]` : arrayAgg;

package/dist/dialect/snowflake/snowflake.d.ts

@@ -36,7 +36,7 @@ export declare class SnowflakeDialect extends Dialect {
     sqlAnyValue(groupSet: number, fieldName: string): string;
     mapFields(fieldList: DialectFieldList): string;
     mapFieldsForObjectConstruct(fieldList: DialectFieldList): string;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/snowflake/snowflake.js

@@ -113,8 +113,10 @@ class SnowflakeDialect extends dialect_1.Dialect {
         const orderByClause = orderBy
             ? ` WITHIN GROUP (${this.sqlTurtleOrderByClause(orderBy)})`
             : '';
-        const filter = filterSQL ? ` AND ${filterSQL}` : '';
-        const aggClause = `ARRAY_AGG(CASE WHEN group_set=${groupSet}${filter} THEN OBJECT_CONSTRUCT_KEEP_NULL(${fields}) END)${orderByClause}`;
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const struct = `OBJECT_CONSTRUCT_KEEP_NULL(${fields})`;
+        const element = cond ? `CASE WHEN ${cond} THEN ${struct} END` : struct;
+        const aggClause = `ARRAY_AGG(${element})${orderByClause}`;
         // ARRAY_SLICE is 0-based, end-exclusive, so (0, n) keeps the first n.
         const limited = limit !== undefined
             ? `ARRAY_SLICE(${aggClause}, 0, ${limit})`

package/dist/dialect/standardsql/standardsql.d.ts

@@ -43,7 +43,7 @@ export declare class StandardSQLDialect extends Dialect {
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;
     sqlOrderBy(orderTerms: string[], obr?: OrderByRequest): string;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/standardsql/standardsql.js

@@ -155,8 +155,10 @@ class StandardSQLDialect extends dialect_1.Dialect {
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
         // BigQuery ARRAY_AGG takes LIMIT as its final sub-clause, after ORDER BY.
         const limitClause = limit !== undefined ? ` LIMIT ${limit}` : '';
-        const filter = filterSQL ? ` AND ${filterSQL}` : '';
-        return `ARRAY_AGG(CASE WHEN group_set=${groupSet}${filter} THEN STRUCT(${fields}\n  ) END IGNORE NULLS ${orderByClause}${limitClause})`;
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const struct = `STRUCT(${fields}\n  )`;
+        const element = cond ? `CASE WHEN ${cond} THEN ${struct} END` : struct;
+        return `ARRAY_AGG(${element} IGNORE NULLS ${orderByClause}${limitClause})`;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList

package/dist/dialect/trino/trino.d.ts

@@ -36,7 +36,7 @@ export declare class TrinoDialect extends PostgresBase {
     exprToSQL(qi: QueryInfo, df: Expr): string | undefined;
     sqlAnyValue(groupSet: number, fieldName: string): string;
     buildTypeExpression(fieldList: DialectFieldList): string;
-    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
+    sqlAggregateTurtle(groupSet: number | undefined, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined, limit?: number, filterSQL?: string): string;
     sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
     sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
     sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;

package/dist/dialect/trino/trino.js

@@ -8,6 +8,7 @@ exports.PrestoDialect = exports.TrinoDialect = void 0;
 const utils_1 = require("../../model/utils");
 const malloy_types_1 = require("../../model/malloy_types");
 const functions_1 = require("../functions");
+const dialect_1 = require("../dialect");
 const pg_impl_1 = require("../pg_impl");
 const dialect_functions_1 = require("./dialect_functions");
 const function_overrides_1 = require("./function_overrides");
@@ -230,8 +231,9 @@ class TrinoDialect extends pg_impl_1.PostgresBase {
         const expressions = fieldList.map(f => f.sqlExpression).join(',\n ');
         const definitions = this.buildTypeExpression(fieldList);
         const orderByClause = orderBy ? this.sqlTurtleOrderByClause(orderBy) : '';
-        const filter = filterSQL ? ` AND ${filterSQL}` : '';
-        const arrayAgg = `ARRAY_AGG(CAST(ROW(${expressions}) AS ROW(${definitions})) ${orderByClause}) FILTER (WHERE group_set=${groupSet}${filter})`;
+        const cond = (0, dialect_1.turtleGroupSetCondition)(groupSet, filterSQL);
+        const filterClause = cond ? ` FILTER (WHERE ${cond})` : '';
+        const arrayAgg = `ARRAY_AGG(CAST(ROW(${expressions}) AS ROW(${definitions})) ${orderByClause})${filterClause}`;
         // SLICE(array, start, length) is 1-based; length n keeps the first n.
         return limit !== undefined ? `SLICE(${arrayAgg}, 1, ${limit})` : arrayAgg;
     }

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

@@ -114,6 +114,10 @@ class DynamicSpace extends static_space_1.StaticSpace {
                 }
             }
             this.sourceDef = { ...this.fromSource, fields: [] };
+            // This is a freshly built (modified) source: it presents a new exported
+            // shape, so it is no longer a reference to the source it was built from.
+            // DefineSource resets referenceID to this source's own sourceID.
+            delete this.sourceDef.referenceID;
             this.sourceDef.parameters = parameters;
             const fieldIndices = new Map();
             // Need to process the entities in specific order
@@ -196,6 +200,7 @@ class DynamicSpace extends static_space_1.StaticSpace {
     emptyStructDef() {
         const ret = { ...this.fromSource };
         ret.fields = [];
+        delete ret.referenceID;
         return ret;
     }
 }

package/dist/lang/ast/source-elements/named-source.js

@@ -91,7 +91,10 @@ class NamedSource extends source_1.Source {
         else {
             (_a = this.document()) === null || _a === void 0 ? void 0 : _a.checkExperimentalDialect(this, entry.dialect);
             if ((0, malloy_types_1.isSourceDef)(entry)) {
-                return { ...entry };
+                // This struct is created as an unmodified reference to `entry`. Mark it
+                // with entry's own identity; the modification path (DynamicSpace) clears
+                // this so only true references carry a referenceID.
+                return { ...entry, referenceID: entry.sourceID };
             }
         }
         // I think this is now a never

package/dist/lang/ast/statements/define-source.js

@@ -58,9 +58,16 @@ class DefineSource extends malloy_element_1.MalloyElement {
                 }
                 : { ...this.note };
         }
-        if ((0, malloy_types_1.isPersistableSourceDef)(entry)) {
+        if ((0, malloy_types_1.isSourceDef)(entry)) {
+            // Every source gets a stable identity for its own definition. referenceID
+            // is left as it arrived: set to the referenced source's sourceID for an
+            // unmodified rename (`source: a is b`), and absent for a source that
+            // defines its own shape (table/sql/query, or a modified/extended source,
+            // which DynamicSpace cleared).
             entry.sourceID = (0, source_def_utils_1.mkSourceID)(this.name, (_b = this.location) === null || _b === void 0 ? void 0 : _b.url);
-            entry.persistent = (0, persist_utils_1.checkPersistAnnotation)(entry).persist;
+            if ((0, malloy_types_1.isPersistableSourceDef)(entry)) {
+                entry.persistent = (0, persist_utils_1.checkPersistAnnotation)(entry).persist;
+            }
         }
         entry.partitionComposite =
             (_d = (0, composite_source_utils_1.getPartitionCompositeDesc)(this.note, structDef, (_c = this.sourceExpr) !== null && _c !== void 0 ? _c : this)) !== null && _d !== void 0 ? _d : structDef.partitionComposite;

package/dist/lang/ast/types/malloy-element.js

@@ -665,10 +665,9 @@ class Document extends MalloyElement {
             this.modelWasModified = true;
         }
         this.documentModel.set(str, ent);
-        // Maintain sourceRegistry for persistable sources with sourceID
-        if ((0, malloy_types_1.isSourceDef)(ent.entry) &&
-            (0, malloy_types_1.isPersistableSourceDef)(ent.entry) &&
-            ent.entry.sourceID) {
+        // Maintain the source-id table so sourceID/referenceID values resolve to
+        // their SourceDef. Every named source is registered by its sourceID.
+        if ((0, malloy_types_1.isSourceDef)(ent.entry) && ent.entry.sourceID) {
             this.documentSrcRegistry[ent.entry.sourceID] = {
                 entry: {
                     type: 'source_registry_reference',

package/dist/model/expression_compiler.js

@@ -143,7 +143,7 @@ function compileExpr(resultSet, context, expr, state = new utils_1.GenerateState
                 else {
                     throw new Error(`Internal Error: Unknown aggregate function ${expr.function}`);
                 }
-                if (resultSet.root().isComplexQuery) {
+                if (resultSet.root().isComplexQuery && resultSet.root().emitsGroupSet) {
                     let groupSet = resultSet.groupSet;
                     if (state.totalGroupSet !== -1) {
                         groupSet = state.totalGroupSet;
@@ -411,7 +411,7 @@ function generateAsymmetricStringAggExpression(resultSet, context, value, separa
     return context.dialect.sqlStringAggDistinct(distinctKey, valueSQL, separatorSQL);
 }
 function generateAnalyticFragment(dialect, resultStruct, context, expr, overload, state, args, partitionByFields, funcOrdering) {
-    const isComplex = resultStruct.root().isComplexQuery;
+    const isComplex = resultStruct.root().isComplexQuery && resultStruct.root().emitsGroupSet;
     const partitionFields = getAnalyticPartitions(resultStruct, partitionByFields);
     const allPartitions = [
         ...(isComplex ? ['group_set'] : []),

package/dist/model/field_instance.d.ts

@@ -96,6 +96,7 @@ export declare class FieldInstanceResultRoot extends FieldInstanceResult {
     joins: Map<string, JoinInstance>;
     havings: AndChain;
     isComplexQuery: boolean;
+    emitsGroupSet: boolean;
     queryUsesPartitioning: boolean;
     computeOnlyGroups: number[];
     elimatedComputeGroups: boolean;

package/dist/model/field_instance.js

@@ -410,6 +410,11 @@ class FieldInstanceResultRoot extends FieldInstanceResult {
         this.joins = new Map();
         this.havings = new utils_1.AndChain();
         this.isComplexQuery = false;
+        // True when the query emits a `group_set` column to demux fanned-out rows
+        // (the general path). The single-group-set fast path (generateSingleGroupSetSQL)
+        // sets this false: there is no group_set column, so aggregate and window
+        // expressions must not wrap themselves in `CASE WHEN group_set=N`.
+        this.emitsGroupSet = true;
         this.queryUsesPartitioning = false;
         this.computeOnlyGroups = [];
         this.elimatedComputeGroups = false;

package/dist/model/index.d.ts

@@ -9,4 +9,5 @@ export { getModelAnnotations } from './annotation_utils';
 export { constantExprToSQL } from './constant_expression_compiler';
 export { getCompiledSQL } from './sql_compiled';
 export { MalloyCompileError } from './malloy_compile_error';
-export { mkSourceID, mkBuildID, mkQuerySourceDef, mkSQLSourceDef, mkTableSourceDef, resolveSourceID, registerSource, hasSourceRegistryEntry, } from './source_def_utils';
+export { mkSourceID, mkBuildID, mkQuerySourceDef, mkSQLSourceDef, mkTableSourceDef, resolveSourceID, resolveSourceRef, sourceNamespaceReference, registerSource, hasSourceRegistryEntry, } from './source_def_utils';
+export type { NamespaceReference } from './source_def_utils';

package/dist/model/index.js

@@ -18,7 +18,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasSourceRegistryEntry = exports.registerSource = exports.resolveSourceID = exports.mkTableSourceDef = exports.mkSQLSourceDef = exports.mkQuerySourceDef = exports.mkBuildID = exports.mkSourceID = exports.MalloyCompileError = exports.getCompiledSQL = exports.constantExprToSQL = exports.getModelAnnotations = exports.typeDefToString = exports.pathToKey = exports.mkModelID = exports.mkModelDef = exports.makeDigest = exports.composeSQLExpr = exports.indent = exports.getResultStructDefForView = exports.getResultStructDefForQuery = exports.QueryModel = exports.QueryQuery = exports.QueryStruct = exports.QueryField = void 0;
+exports.hasSourceRegistryEntry = exports.registerSource = exports.sourceNamespaceReference = exports.resolveSourceRef = exports.resolveSourceID = exports.mkTableSourceDef = exports.mkSQLSourceDef = exports.mkQuerySourceDef = exports.mkBuildID = exports.mkSourceID = exports.MalloyCompileError = exports.getCompiledSQL = exports.constantExprToSQL = exports.getModelAnnotations = exports.typeDefToString = exports.pathToKey = exports.mkModelID = exports.mkModelDef = exports.makeDigest = exports.composeSQLExpr = exports.indent = exports.getResultStructDefForView = exports.getResultStructDefForQuery = exports.QueryModel = exports.QueryQuery = exports.QueryStruct = exports.QueryField = void 0;
 __exportStar(require("./malloy_types"), exports);
 const query_node_1 = require("./query_node");
 Object.defineProperty(exports, "QueryField", { enumerable: true, get: function () { return query_node_1.QueryField; } });
@@ -60,6 +60,8 @@ Object.defineProperty(exports, "mkQuerySourceDef", { enumerable: true, get: func
 Object.defineProperty(exports, "mkSQLSourceDef", { enumerable: true, get: function () { return source_def_utils_1.mkSQLSourceDef; } });
 Object.defineProperty(exports, "mkTableSourceDef", { enumerable: true, get: function () { return source_def_utils_1.mkTableSourceDef; } });
 Object.defineProperty(exports, "resolveSourceID", { enumerable: true, get: function () { return source_def_utils_1.resolveSourceID; } });
+Object.defineProperty(exports, "resolveSourceRef", { enumerable: true, get: function () { return source_def_utils_1.resolveSourceRef; } });
+Object.defineProperty(exports, "sourceNamespaceReference", { enumerable: true, get: function () { return source_def_utils_1.sourceNamespaceReference; } });
 Object.defineProperty(exports, "registerSource", { enumerable: true, get: function () { return source_def_utils_1.registerSource; } });
 Object.defineProperty(exports, "hasSourceRegistryEntry", { enumerable: true, get: function () { return source_def_utils_1.hasSourceRegistryEntry; } });
 //# sourceMappingURL=index.js.map

package/dist/model/malloy_types.d.ts

@@ -858,6 +858,22 @@ interface SourceDefBase extends StructDefBase, Filtered, ResultStructMetadata {
     primaryKey?: PrimaryKeyRef;
     dialect: string;
     partitionComposite?: PartitionCompositeDesc;
+    /**
+     * Identity of this source's own definition (`name@modelURL`). Set for every
+     * source when it is defined. The persistence machinery reads this (gated by
+     * `isPersistableSourceDef`).
+     */
+    sourceID?: SourceID;
+    /**
+     * Set only when this source was created as an unmodified reference to another
+     * source (`source: a is b`, or a plain join) — then it holds the `sourceID`
+     * of the *immediately* referenced source. Absent when the source defines its
+     * own shape (table/sql/query, or a modified/extended source). So
+     * `referenceID !== undefined` means "created as a reference", and the value
+     * resolves through `ModelDef.sourceRegistry` to the referenced source and its
+     * namespace name (see `sourceNamespaceReference`).
+     */
+    referenceID?: SourceID;
 }
 /** which field is the primary key in this struct */
 export type PrimaryKeyRef = string;
@@ -878,7 +894,7 @@ export interface SQLStringSegment {
 export type SQLPhraseSegment = Query | PersistableSourceDef | SQLStringSegment;
 export declare function isSegmentSQL(f: SQLPhraseSegment): f is SQLStringSegment;
 export declare function isSegmentSource(f: SQLPhraseSegment): f is PersistableSourceDef;
-/** Format: "name@modelUrl" - uniquely identifies a source for persistence */
+/** Format: "name@modelUrl" - uniquely identifies a defined source */
 export type SourceID = string;
 /** Created with `mkGivenID`. */
 export type GivenID = string;
@@ -915,7 +931,6 @@ export interface SourceRegistryValue {
 }
 export declare function isSourceRegistryReference(entry: SourceRegistryEntry): entry is SourceRegistryReference;
 export interface PersistableSourceProperties {
-    sourceID?: SourceID;
     extends?: SourceID;
     persistent?: boolean;
 }
@@ -943,13 +958,17 @@ export declare function isSourceDef(sd: NamedModelObject | FieldDef): sd is Sour
 /**
  * Union of all source definition types.
  *
- * IMPORTANT: Never use object spread to copy a SourceDef. Use the factory
- * methods in source_def_utils.ts to merge changes into a source def:
+ * When building a *persisted/derived* source in the compiler, use the factory
+ * methods in source_def_utils.ts rather than object spread:
  * - mkSQLSourceDef(base, ...) - create SQLSourceDef from base
  * - mkQuerySourceDef(base, ...) - create QuerySourceDef from base
  *
- * These factories explicitly copy only safe fields, preventing accidental
- * propagation of sourceID/extends which must only be set in DefineSource.
+ * These factories explicitly copy only safe fields, dropping the identity
+ * fields (sourceID/referenceID/extends/persistent) so they are not propagated
+ * onto a freshly built source. In the translator, by contrast, object spread is
+ * used deliberately to *carry* sourceID/referenceID through an unmodified
+ * reference; DefineSource then sets them, and DynamicSpace clears referenceID
+ * on the modification path.
  */
 export type SourceDef = TableSourceDef | SQLSourceDef | QuerySourceDef | QueryResultDef | FinalizeSourceDef | NestSourceDef | VirtualSourceDef | CompositeSourceDef;
 /** Sources that can be persisted (materialized to tables) */

package/dist/model/persist_utils.js

@@ -145,7 +145,7 @@ function findPersistentDependencies(root, modelDef, tagParseLog = []) {
         return results;
     }
     function processJoinedSource(source) {
-        // If it has a sourceID, go through the registry
+        // If it has an sourceID, go through the registry
         if ((0, malloy_types_1.isPersistableSourceDef)(source) && source.sourceID) {
             return processSourceID(source.sourceID);
         }

package/dist/model/query_query.d.ts

@@ -91,7 +91,25 @@ export declare class QueryQuery extends QueryField {
      */
     collectArrayJoins(ji: JoinInstance): JoinInstance[];
     genereateSQLOrderBy(queryDef: QuerySegment, resultStruct: FieldInstanceResult): string;
+    /**
+     * The single-scan form, with no `group_set` fan-out: one `SELECT` over the
+     * scan, grouped by the dimensions. Used both for a query with no nests and --
+     * via canUseSingleGroupSetSQL -- for one whose only nests are single-stage
+     * grain-preserving projections, which become an array-agg in the same SELECT.
+     * That array-agg needs no `FILTER (WHERE group_set=N)` (every row is in the
+     * one group), and aggregate/window expressions must not gate themselves by
+     * group_set either, so emitsGroupSet is cleared (see FieldInstanceResultRoot).
+     */
     generateSimpleSQL(stageWriter: StageWriter): string;
+    /**
+     * Can this query take the single-group-set fast path? True when the query
+     * needs no group-set fan-out: it has nests (so it's "complex") but every one
+     * is a single-stage grain-preserving projection riding group_set 0, and there
+     * are no reduce nests, ungroupings, or totals (all of which would mint a
+     * second group set and push maxGroupSet above 0). Anything outside that shape
+     * falls back to the general demux path, which is correct for every case.
+     */
+    canUseSingleGroupSetSQL(): boolean;
     generatePipelinedStages(outputPipelinedSQL: OutputPipelinedSQL[], lastStageName: string, stageWriter: StageWriter, priorStageColumns: StageOutputColumn[]): string;
     generateStage0Fields(resultSet: FieldInstanceResult, output: StageOutputContext, stageWriter: StageWriter): void;
     generateSQLWhereChildren(resultStruct: FieldInstanceResult): AndChain;
@@ -102,7 +120,7 @@ export declare class QueryQuery extends QueryField {
     generateSQLDepthN(depth: number, stageWriter: StageWriter, stageName: string): string;
     genereateSQLCombineTurtles(stageWriter: StageWriter, stage0Name: string): string;
     buildDialectFieldList(resultStruct: FieldInstanceResult): DialectFieldList;
-    generateTurtleSQL(resultStruct: FieldInstanceResult, stageWriter: StageWriter, sqlFieldName: string, outputPipelinedSQL: OutputPipelinedSQL[]): string;
+    generateTurtleSQL(resultStruct: FieldInstanceResult, stageWriter: StageWriter, sqlFieldName: string, outputPipelinedSQL: OutputPipelinedSQL[], omitGroupSetFilter?: boolean): string;
     generateTurtlePipelineSQL(fi: FieldInstanceResult, stageWriter: StageWriter, sourceSQLExpression: string): {
         structDef: QueryResultDef;
         pipeOut: any;

package/dist/model/query_query.js

@@ -30,6 +30,11 @@ function usesShaveLimit(result) {
     const isNestedProjection = result.parent !== undefined && result.firstSegment.type === 'project';
     return !isNestedProjection;
 }
+/** Is this an analytic (window) field -- a `calculate:`? */
+function fieldIsAnalytic(fi) {
+    return ((0, malloy_types_1.hasExpression)(fi.f.fieldDef) &&
+        (0, malloy_types_1.expressionIsAnalytic)(fi.f.fieldDef.expressionType));
+}
 // 1-based SELECT positions of the dimension columns, for `GROUP BY 1,2,...`.
 function groupByPositions(columns) {
     return columns.flatMap((c, i) => (c.isDimension ? [i + 1] : []));
@@ -903,15 +908,31 @@ class QueryQuery extends query_node_1.QueryField {
         }
         return s;
     }
+    /**
+     * The single-scan form, with no `group_set` fan-out: one `SELECT` over the
+     * scan, grouped by the dimensions. Used both for a query with no nests and --
+     * via canUseSingleGroupSetSQL -- for one whose only nests are single-stage
+     * grain-preserving projections, which become an array-agg in the same SELECT.
+     * That array-agg needs no `FILTER (WHERE group_set=N)` (every row is in the
+     * one group), and aggregate/window expressions must not gate themselves by
+     * group_set either, so emitsGroupSet is cleared (see FieldInstanceResultRoot).
+     */
     generateSimpleSQL(stageWriter) {
+        this.rootResult.emitsGroupSet = false;
         let s = '';
         s += 'SELECT \n';
         const fields = [];
-        for (const [name, field] of this.rootResult.allFields) {
-            const fi = field;
+        const outputPipelinedSQL = [];
+        for (const [name, fi] of this.rootResult.allFields) {
             const sqlName = this.parent.dialect.sqlQuoteIdentifier(name);
-            if (fi.fieldUsage.type === 'result') {
-                fields.push(` ${fi.generateExpression()} as ${sqlName}`);
+            if (fi instanceof field_instance_1.FieldInstanceField) {
+                if (fi.fieldUsage.type === 'result') {
+                    fields.push(` ${fi.generateExpression()} as ${sqlName}`);
+                }
+            }
+            else if (fi instanceof field_instance_1.FieldInstanceResult) {
+                const turtle = this.generateTurtleSQL(fi, stageWriter, sqlName, outputPipelinedSQL, true);
+                fields.push(` ${turtle} as ${sqlName}`);
             }
         }
         s += (0, utils_1.indent)(fields.join(',\n')) + '\n';
@@ -938,8 +959,52 @@ class QueryQuery extends query_node_1.QueryField {
             s += `LIMIT ${this.firstSegment.limit}\n`;
         }
         this.resultStage = stageWriter.addStage(s);
+        // Consumes any pipelined turtle output. The nests that reach here are
+        // single-stage (canUseSingleGroupSetSQL), so outputPipelinedSQL is empty and
+        // this is a no-op; kept so the function stays correct if that guard widens.
+        this.resultStage = this.generatePipelinedStages(outputPipelinedSQL, this.resultStage, stageWriter, []);
         return this.resultStage;
     }
+    /**
+     * Can this query take the single-group-set fast path? True when the query
+     * needs no group-set fan-out: it has nests (so it's "complex") but every one
+     * is a single-stage grain-preserving projection riding group_set 0, and there
+     * are no reduce nests, ungroupings, or totals (all of which would mint a
+     * second group set and push maxGroupSet above 0). Anything outside that shape
+     * falls back to the general demux path, which is correct for every case.
+     */
+    canUseSingleGroupSetSQL() {
+        if (this.maxGroupSet !== 0)
+            return false;
+        if (this.firstSegment.type !== 'reduce')
+            return false;
+        for (const [, fi] of this.rootResult.allFields) {
+            if (fi instanceof field_instance_1.FieldInstanceField) {
+                // A root-level `calculate:` (window) needs the general path's analytic
+                // handling: on dialects that can't partition a window on an expression
+                // (BigQuery) it rides a lateral-join bag this path doesn't build.
+                if (fieldIsAnalytic(fi))
+                    return false;
+            }
+            else if (fi instanceof field_instance_1.FieldInstanceResult) {
+                if (fi.firstSegment.type !== 'project')
+                    return false;
+                if (fi.turtleDef.pipeline.length !== 1)
+                    return false;
+                if (fi.getRepeatedResultType() !== 'nested')
+                    return false;
+                // A `calculate:` inside a `select:` would put a window function inside
+                // the array-agg, which no dialect allows; leave it on the general path.
+                for (const [, nestField] of fi.allFields) {
+                    if (nestField instanceof field_instance_1.FieldInstanceField &&
+                        fieldIsAnalytic(nestField)) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
     // This probably should be generated in a dialect independat way.
     //  but for now, it is just googleSQL.
     generatePipelinedStages(outputPipelinedSQL, lastStageName, stageWriter, 
@@ -1509,7 +1574,12 @@ class QueryQuery extends query_node_1.QueryField {
         }
         return dialectFieldList;
     }
-    generateTurtleSQL(resultStruct, stageWriter, sqlFieldName, outputPipelinedSQL) {
+    generateTurtleSQL(resultStruct, stageWriter, sqlFieldName, outputPipelinedSQL, 
+    // The single-group-set fast path (generateSingleGroupSetSQL) has no
+    // group_set column to filter on: every row is in the one group. The
+    // array-agg drops its `FILTER (WHERE group_set=N)` and keeps only a
+    // projection's own `where:`.
+    omitGroupSetFilter = false) {
         // How to emit this nest's first stage — and the last line of defense before
         // broken SQL for IR that didn't pass through the translator (cached,
         // deserialized, or query-builder IR). Same `nestStrategy` the translator
@@ -1580,7 +1650,7 @@ class QueryQuery extends query_node_1.QueryField {
                 }
             }
             // (capability is guarded by nestStrategy at the top of this method)
-            ret = this.parent.dialect.sqlAggregateTurtle(resultStruct.groupSet, dialectFieldList, orderBy, limit, filterSQL);
+            ret = this.parent.dialect.sqlAggregateTurtle(omitGroupSetFilter ? undefined : resultStruct.groupSet, dialectFieldList, orderBy, limit, filterSQL);
         }
         // If the turtle is a pipeline, generate a UDF to compute it.
         const newStageWriter = new stage_writer_1.StageWriter(this.parent.dialect.supportsCTEinCoorelatedSubQueries, stageWriter);
@@ -1658,12 +1728,13 @@ class QueryQuery extends query_node_1.QueryField {
         this.maxGroupSet = r.nextGroupSetNumber - 1;
         this.rootResult.assignFieldsToGroups();
         (_a = this.rootResult).isComplexQuery || (_a.isComplexQuery = this.maxDepth > 0 || r.isComplex);
-        if (this.rootResult.isComplexQuery) {
+        // A complex query needs the group-set fan-out unless it has just one group
+        // set (only single-stage projection nests), in which case generateSimpleSQL
+        // emits the same no-fan-out form a non-nested query gets.
+        if (this.rootResult.isComplexQuery && !this.canUseSingleGroupSetSQL()) {
             return this.generateComplexSQL(stageWriter);
         }
-        else {
-            return this.generateSimpleSQL(stageWriter);
-        }
+        return this.generateSimpleSQL(stageWriter);
     }
     generateSQLFromPipeline(stageWriter) {
         this.parent.maybeEmitParameterizedSourceUsage();

package/dist/model/source_def_utils.d.ts

@@ -1,11 +1,11 @@
 /**
  * SourceDef Utilities for Persistence
  *
- * Key invariant: sourceID is ONLY assigned in DefineSource when a source
- * gets a name. Factory functions explicitly copy only the fields they need,
- * never using spread, to prevent accidental propagation of sourceID/extends.
- *
- * The `extends` property is set by callers when processing extend blocks.
+ * Key invariant: a source's identity fields (sourceID, referenceID, extends)
+ * are assigned in the translator (DefineSource / the reference path), never by
+ * these compiler factories. The factory functions explicitly copy only the
+ * fields they need, never using spread, so identity is not propagated onto a
+ * freshly built source.
  */
 import type { BuildID, FieldDef, GivenID, ModelDef, PersistableSourceDef, Query, QuerySourceDef, SourceDef, SourceID, SourceRegistryEntry, SourceRegistryValue, SQLPhraseSegment, SQLSourceDef, TableSourceDef } from './malloy_types';
 export declare function mkSourceID(name: string, url: string | undefined): SourceID;
@@ -30,13 +30,37 @@ export declare function mkSQLSourceDef(base: SourceDef, selectStr: string, selec
  */
 export declare function mkTableSourceDef(name: string, connection: string, tablePath: string, dialect: string, fields: FieldDef[]): TableSourceDef;
 /**
- * Resolve a sourceID to a SourceDef using the sourceRegistry.
+ * Resolve a SourceID (a source's own `sourceID`, or a `referenceID` pointing at
+ * one) to its SourceDef using the sourceRegistry, returning any kind of source.
  *
  * @param modelDef The model definition containing the registry
- * @param sourceID The sourceID to resolve
+ * @param sourceID The SourceID to resolve
  * @returns The SourceDef if found, undefined otherwise
  */
+export declare function resolveSourceRef(modelDef: ModelDef, sourceID: SourceID): SourceDef | undefined;
+/**
+ * Resolve a sourceID to a persistable SourceDef using the sourceRegistry.
+ *
+ * @param modelDef The model definition containing the registry
+ * @param sourceID The sourceID to resolve
+ * @returns The PersistableSourceDef if found, undefined otherwise
+ */
 export declare function resolveSourceID(modelDef: ModelDef, sourceID: SourceID): PersistableSourceDef | undefined;
+/** The namespace entry a source refers to (see `sourceNamespaceReference`). */
+export interface NamespaceReference {
+    /** The name this source is bound to in `modelDef.contents`. */
+    name: string;
+    /** The referenced source. */
+    source: SourceDef;
+}
+/**
+ * If `sd` was created as an unmodified reference to another source
+ * (`sd.referenceID` is set) and that source is present in this model's
+ * namespace, return it together with the name it goes by. Returns undefined
+ * when `sd` defines its own shape, or when the referenced source is not in this
+ * model's namespace (e.g. an imported source whose own target wasn't imported).
+ */
+export declare function sourceNamespaceReference(modelDef: ModelDef, sd: SourceDef): NamespaceReference | undefined;
 /**
  * Add an entry to the sourceRegistry.
  *

package/dist/model/source_def_utils.js

@@ -10,7 +10,9 @@ exports.mkBuildID = mkBuildID;
 exports.mkQuerySourceDef = mkQuerySourceDef;
 exports.mkSQLSourceDef = mkSQLSourceDef;
 exports.mkTableSourceDef = mkTableSourceDef;
+exports.resolveSourceRef = resolveSourceRef;
 exports.resolveSourceID = resolveSourceID;
+exports.sourceNamespaceReference = sourceNamespaceReference;
 exports.registerSource = registerSource;
 exports.hasSourceRegistryEntry = hasSourceRegistryEntry;
 const utils_1 = require("./utils");
@@ -59,8 +61,9 @@ function mkQuerySourceDef(base, query, name) {
         dialect: base.dialect,
         partitionComposite: base.partitionComposite,
         errorFactory: base.errorFactory,
-        // PersistableSourceProperties - explicitly NOT copied
+        // Identity fields - explicitly NOT copied
         // sourceID: undefined,
+        // referenceID: undefined,
         // extends: undefined,
         // persistent: undefined,
     };
@@ -97,8 +100,9 @@ function mkSQLSourceDef(base, selectStr, selectSegments) {
         dialect: base.dialect,
         partitionComposite: base.partitionComposite,
         errorFactory: base.errorFactory,
-        // PersistableSourceProperties - explicitly NOT copied
+        // Identity fields - explicitly NOT copied
         // sourceID: undefined,
+        // referenceID: undefined,
         // extends: undefined,
         // persistent: undefined,
     };
@@ -120,25 +124,51 @@ function mkTableSourceDef(name, connection, tablePath, dialect, fields) {
 // Source Registry Utilities
 // =============================================================================
 /**
- * Resolve a sourceID to a SourceDef using the sourceRegistry.
+ * Resolve a SourceID (a source's own `sourceID`, or a `referenceID` pointing at
+ * one) to its SourceDef using the sourceRegistry, returning any kind of source.
  *
  * @param modelDef The model definition containing the registry
- * @param sourceID The sourceID to resolve
+ * @param sourceID The SourceID to resolve
  * @returns The SourceDef if found, undefined otherwise
  */
-function resolveSourceID(modelDef, sourceID) {
+function resolveSourceRef(modelDef, sourceID) {
     const value = modelDef.sourceRegistry[sourceID];
     if (!value)
         return undefined;
     if ((0, malloy_types_1.isSourceRegistryReference)(value.entry)) {
         const obj = (0, malloy_types_1.safeRecordGet)(modelDef.contents, value.entry.name);
-        return obj && (0, malloy_types_1.isSourceDef)(obj) && (0, malloy_types_1.isPersistableSourceDef)(obj)
-            ? obj
-            : undefined;
+        return obj && (0, malloy_types_1.isSourceDef)(obj) ? obj : undefined;
     }
-    // It's a PersistableSourceDef
     return value.entry;
 }
+/**
+ * Resolve a sourceID to a persistable SourceDef using the sourceRegistry.
+ *
+ * @param modelDef The model definition containing the registry
+ * @param sourceID The sourceID to resolve
+ * @returns The PersistableSourceDef if found, undefined otherwise
+ */
+function resolveSourceID(modelDef, sourceID) {
+    const sd = resolveSourceRef(modelDef, sourceID);
+    return sd && (0, malloy_types_1.isPersistableSourceDef)(sd) ? sd : undefined;
+}
+/**
+ * If `sd` was created as an unmodified reference to another source
+ * (`sd.referenceID` is set) and that source is present in this model's
+ * namespace, return it together with the name it goes by. Returns undefined
+ * when `sd` defines its own shape, or when the referenced source is not in this
+ * model's namespace (e.g. an imported source whose own target wasn't imported).
+ */
+function sourceNamespaceReference(modelDef, sd) {
+    if (sd.referenceID === undefined)
+        return undefined;
+    const value = modelDef.sourceRegistry[sd.referenceID];
+    if (!value || !(0, malloy_types_1.isSourceRegistryReference)(value.entry))
+        return undefined;
+    const name = value.entry.name;
+    const source = (0, malloy_types_1.safeRecordGet)(modelDef.contents, name);
+    return source && (0, malloy_types_1.isSourceDef)(source) ? { name, source } : undefined;
+}
 /**
  * Add an entry to the sourceRegistry.
  *

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.413";
+export declare const MALLOY_VERSION = "0.0.414";

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

package/package.json

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