@malloydata/malloy 0.0.391 → 0.0.393

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

@@ -0,0 +1,163 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefineGivens = exports.GivenDeclaration = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const source_def_utils_1 = require("../../../model/source_def_utils");
+const utils_1 = require("../../../model/utils");
+const expression_def_1 = require("../types/expression-def");
+const malloy_element_1 = require("../types/malloy-element");
+const noteable_1 = require("../types/noteable");
+// `filter<T>` defaults can't be type-checked via TD.eq — the filter
+// expression value shape doesn't match an atomic typeDef. Catch only
+// the gross kind mismatch here; inner-content validation (filter
+// syntax + T compatibility) belongs to the filter machinery at use
+// site.
+function filterTypeMismatch(declared, constVal) {
+    return ((declared.type === 'filter expression') !==
+        (constVal.type === 'filter expression'));
+}
+class GivenDeclaration extends malloy_element_1.MalloyElement {
+    constructor(name, typeDef, defaultExpr) {
+        super();
+        this.name = name;
+        this.typeDef = typeDef;
+        this.elementType = 'given';
+        this.isNoteableObj = true;
+        this.extendNote = noteable_1.extendNoteMethod;
+        if (defaultExpr) {
+            this.default = defaultExpr;
+            this.has({ default: defaultExpr });
+        }
+    }
+    varInfo() {
+        return ` ${this.name} :: ${(0, utils_1.typeDefToString)(this.typeDef)}`;
+    }
+    execute(doc) {
+        var _a, _b, _c, _d, _e;
+        if (this.typeDef.type === 'error')
+            return;
+        if (doc.modelEntry(this.name)) {
+            this.logError('given-definition-name-conflict', `Cannot redefine '${this.name}'`);
+            return;
+        }
+        // Default expression. ConstantExpression evaluates through a
+        // ConstantFieldSpace that errors on every name lookup, so any
+        // non-constant subexpression (field refs, aggregates, etc.) gets
+        // logged here. `$NAME` references bypass that field space (see
+        // GivenReference.getExpression) so given-to-given refs in defaults
+        // are allowed.
+        let defaultExpr;
+        let givenUsage;
+        if (this.default) {
+            const constVal = this.default.constantValue();
+            if (constVal.type !== 'error') {
+                // `X :: timestamp is @2024-01-01` works because date literals
+                // carry a morphic.timestamp. Date/timestamp are the only
+                // MorphicType targets — other declared types fall through to
+                // the TD.eq check below.
+                const morphed = this.typeDef.type === 'date' || this.typeDef.type === 'timestamp'
+                    ? (0, expression_def_1.getMorphicValue)(constVal, this.typeDef.type)
+                    : undefined;
+                // `filter<T>` defaults are filter-expression literals — their
+                // shape doesn't match an atomic typeDef, so type-check there is
+                // owned by the filter machinery, not us. `null` is implicitly
+                // accepted for any declared type.
+                if (constVal.type !== 'null' &&
+                    morphed === undefined &&
+                    (filterTypeMismatch(this.typeDef, constVal) ||
+                        !malloy_types_1.TD.eq(this.typeDef, constVal))) {
+                    const actual = malloy_types_1.TD.isAtomic(constVal)
+                        ? (0, utils_1.typeDefToString)(constVal)
+                        : constVal.type;
+                    this.default.logError('parameter-default-does-not-match-declared-type', `Default value of type \`${actual}\` does not match declared type \`${(0, utils_1.typeDefToString)(this.typeDef)}\``);
+                }
+                else if (this.typeDef.type === 'filter expression' &&
+                    constVal.type === 'filter expression') {
+                    // We know T at the declaration site, so validate the filter
+                    // literal here even though the filter machinery will check it
+                    // again at use site. Catches bad filter syntax early.
+                    (0, expression_def_1.checkFilterExpression)(this.default, this.typeDef.filterType, constVal.value);
+                }
+                defaultExpr = (_a = morphed === null || morphed === void 0 ? void 0 : morphed.value) !== null && _a !== void 0 ? _a : constVal.value;
+                // Build the transitive closure of givens reachable through this
+                // default's expression. We only include direct refs PLUS each
+                // referenced given's already-precomputed transitive (which is
+                // present because Malloy requires `$X` to resolve to a given
+                // declared earlier or imported). The satisfiability check then
+                // becomes a flat iteration — no recursion at check time.
+                //
+                // For `A :: number is $B + 1` where `B :: number is $C`:
+                //   - B's givenUsage was computed when B was declared = [C]
+                //   - A's givenUsage = [B] ∪ B.givenUsage = [B, C]
+                const directRefs = (0, malloy_types_1.givenUsageFrom)(constVal.refSummary);
+                if (directRefs.length > 0) {
+                    const seen = new Set();
+                    const closure = [];
+                    for (const g of directRefs) {
+                        if (seen.has(g.id))
+                            continue;
+                        seen.add(g.id);
+                        closure.push(g);
+                        const refDecl = doc.documentGivens.get(g.id);
+                        for (const t of (_b = refDecl === null || refDecl === void 0 ? void 0 : refDecl.givenUsage) !== null && _b !== void 0 ? _b : []) {
+                            if (seen.has(t.id))
+                                continue;
+                            seen.add(t.id);
+                            closure.push(t);
+                        }
+                    }
+                    givenUsage = closure;
+                }
+            }
+        }
+        const id = (0, source_def_utils_1.mkGivenID)(this.name, (_c = this.location) === null || _c === void 0 ? void 0 : _c.url);
+        const defaultText = defaultExpr !== undefined ? (_d = this.default) === null || _d === void 0 ? void 0 : _d.code : undefined;
+        const givenIR = {
+            name: this.name,
+            type: this.typeDef,
+            default: defaultExpr,
+            defaultText,
+            givenUsage,
+            location: this.location,
+            annotation: this.note,
+        };
+        doc.documentGivens.set(id, givenIR);
+        const entry = { type: 'given', name: this.name, id };
+        doc.setEntry(this.name, { entry, exported: true });
+        // Declaration-site reference. `location` covers the whole
+        // declaration; `definition.location` points at the same place.
+        // Self-referential by design — parallel to how fieldReference
+        // behaves on field declarations.
+        this.addReference({
+            type: 'givenReference',
+            text: this.name,
+            location: (_e = this.location) !== null && _e !== void 0 ? _e : {
+                url: '',
+                range: {
+                    start: { line: 0, character: 0 },
+                    end: { line: 0, character: 0 },
+                },
+            },
+            definition: {
+                type: (0, utils_1.typeDefToString)(this.typeDef),
+                annotation: this.note,
+                location: this.location,
+                defaultText,
+            },
+        });
+    }
+}
+exports.GivenDeclaration = GivenDeclaration;
+class DefineGivens extends malloy_element_1.DocStatementList {
+    constructor(givens) {
+        super(givens);
+        this.elementType = 'defineGivens';
+        this.givens = givens;
+    }
+}
+exports.DefineGivens = DefineGivens;
+//# sourceMappingURL=define-given.js.map

package/dist/lang/ast/statements/import-statement.js

@@ -27,6 +27,7 @@ const malloy_element_1 = require("../types/malloy-element");
 const malloy_types_1 = require("../../../model/malloy_types");
 const source_def_utils_1 = require("../../../model/source_def_utils");
 const persist_utils_1 = require("../../../model/persist_utils");
+const utils_1 = require("../../../model/utils");
 /** Walk BuildNode tree and collect all sourceIDs */
 function collectSourceIDs(nodes, into) {
     for (const node of nodes) {
@@ -87,6 +88,7 @@ class ImportStatement extends malloy_element_1.ListOf {
         return undefined;
     }
     execute(doc) {
+        var _a;
         const trans = this.translator();
         if (!trans) {
             this.logError('no-translator-for-import', 'Cannot import without translation context');
@@ -98,7 +100,10 @@ class ImportStatement extends malloy_element_1.ListOf {
                 const importedModel = trans.importModelDef(this.fullURL);
                 if (importedModel) {
                     const importAll = this.empty();
-                    const explicitImport = {};
+                    // `Map` rather than plain object — keys are user-provided names and
+                    // a plain object would expose Object.prototype keys (`toString`,
+                    // etc.).
+                    const explicitImport = new Map();
                     for (const importOne of this.list) {
                         const dstName = importOne.text;
                         const srcName = importOne.from ? importOne.from.text : dstName;
@@ -109,20 +114,64 @@ class ImportStatement extends malloy_element_1.ListOf {
                             importOne.logError('name-conflict-on-selective-import', `Cannot redefine '${dstName}'`);
                         }
                         else {
-                            if (explicitImport[srcName] === undefined) {
-                                explicitImport[srcName] = [];
+                            const existing = explicitImport.get(srcName);
+                            if (existing) {
+                                existing.push(dstName);
+                            }
+                            else {
+                                explicitImport.set(srcName, [dstName]);
                             }
-                            explicitImport[srcName].push(dstName);
                         }
                     }
                     const neededSourceIDs = new Set();
                     for (const srcName of importedModel.exports) {
-                        const pickedNames = explicitImport[srcName];
-                        const dstNames = pickedNames || (importAll ? [srcName] : []);
+                        const pickedNames = explicitImport.get(srcName);
+                        const dstNames = pickedNames !== null && pickedNames !== void 0 ? pickedNames : (importAll ? [srcName] : []);
                         for (const dstName of dstNames) {
-                            const importMe = {
-                                ...(0, malloy_types_1.safeRecordGet)(importedModel.contents, srcName),
-                            };
+                            const sourceEntry = (0, malloy_types_1.safeRecordGet)(importedModel.contents, srcName);
+                            // Non-selective collision: an entry would shadow something
+                            // already in the importer's namespace (a local declaration or
+                            // an entry brought in by a previous import). Selective
+                            // collisions are caught by the per-item check at the top of
+                            // the loop; here we re-check because the auto-surface path
+                            // bypasses that loop. Applies to every entry kind.
+                            if (!pickedNames && doc.getEntry(dstName)) {
+                                this.logError('name-conflict-on-indiscriminate-import', `Cannot redefine '${dstName}'`);
+                                continue;
+                            }
+                            if ((sourceEntry === null || sourceEntry === void 0 ? void 0 : sourceEntry.type) === 'given') {
+                                const givenEntry = {
+                                    type: 'given',
+                                    name: dstName,
+                                    id: sourceEntry.id,
+                                };
+                                doc.setEntry(dstName, { entry: givenEntry, exported: false });
+                                // Selective import-site reference. `location` covers
+                                // the `NAME` token in the selective list;
+                                // `definition.location` points at the canonical
+                                // `given:` declaration in the imported file. Only
+                                // emitted on the selective form — non-selective
+                                // auto-surface has no per-name source position.
+                                if (pickedNames) {
+                                    const givenIR = (_a = importedModel.givens) === null || _a === void 0 ? void 0 : _a[sourceEntry.id];
+                                    const importOne = this.list.find(item => item.text === dstName);
+                                    if (importOne && givenIR) {
+                                        this.addReference({
+                                            type: 'givenReference',
+                                            text: dstName,
+                                            location: importOne.location,
+                                            definition: {
+                                                type: (0, utils_1.typeDefToString)(givenIR.type),
+                                                annotation: givenIR.annotation,
+                                                location: givenIR.location,
+                                                defaultText: givenIR.defaultText,
+                                            },
+                                        });
+                                    }
+                                }
+                                continue;
+                            }
+                            const importMe = { ...sourceEntry };
                             importMe.as = dstName;
                             doc.setEntry(dstName, { entry: importMe, exported: false });
                             // Collect dependencies for persistable sources
@@ -132,6 +181,20 @@ class ImportStatement extends malloy_element_1.ListOf {
                             }
                         }
                     }
+                    // Always copy the imported model's given declarations into the
+                    // local givens map, regardless of whether each given is surfaced
+                    // into the namespace. This guarantees that any givenRef in
+                    // imported IR (sources/queries that reference `$X`) resolves to
+                    // a declaration at SQL-emission time. The import-time
+                    // satisfiability check that catches unsatisfiable refs lands
+                    // with the refSummary work.
+                    if (importedModel.givens) {
+                        for (const [id, given] of Object.entries(importedModel.givens)) {
+                            if (!doc.documentGivens.has(id)) {
+                                doc.documentGivens.set(id, given);
+                            }
+                        }
+                    }
                     // Register hidden dependencies from child's registry
                     for (const sourceID of neededSourceIDs) {
                         if (!(sourceID in doc.documentSrcRegistry)) {

package/dist/lang/ast/typedesc-utils.d.ts

@@ -43,7 +43,9 @@ export declare function typeEq(left: TypeDesc, right: TypeDesc, nullOk?: boolean
 export declare function inspect(...types: (TypeDesc | undefined)[]): string;
 /**
  * Used when using a TypeDesc or TypeDesc-like interface to
- * create a field, don't copy the non type fields.
+ * create a field, don't copy the non type fields. Thin wrapper over
+ * `TD.atomicDef`; exists in `lang/` so callers can pass a `TypeDesc`
+ * (translator-side) without leaking that type into the model layer.
  */
 export declare function atomicDef(td: AtomicTypeDef | TypeDesc): AtomicTypeDef;
 export declare function parameterTypeDesc(p: Parameter, evalSpace: EvalSpace): TypeDesc;

package/dist/lang/ast/typedesc-utils.js

@@ -40,7 +40,6 @@ dataType, expressionType = 'scalar', evalSpace = 'constant') {
         type: dataType,
         expressionType,
         evalSpace,
-        fieldUsage: [],
     };
 }
 exports.nullT = mkTypeDesc('null');
@@ -120,53 +119,12 @@ function inspect(...types) {
 }
 /**
  * Used when using a TypeDesc or TypeDesc-like interface to
- * create a field, don't copy the non type fields.
+ * create a field, don't copy the non type fields. Thin wrapper over
+ * `TD.atomicDef`; exists in `lang/` so callers can pass a `TypeDesc`
+ * (translator-side) without leaking that type into the model layer.
  */
 function atomicDef(td) {
-    if (model_1.TD.isAtomic(td)) {
-        switch (td.type) {
-            case 'array': {
-                return (0, model_1.isRepeatedRecord)(td)
-                    ? {
-                        type: 'array',
-                        elementTypeDef: td.elementTypeDef,
-                        fields: td.fields,
-                    }
-                    : {
-                        type: 'array',
-                        elementTypeDef: td.elementTypeDef,
-                    };
-            }
-            case 'record': {
-                return { type: 'record', fields: td.fields };
-            }
-            case 'number': {
-                return td.numberType
-                    ? { type: 'number', numberType: td.numberType }
-                    : { type: 'number' };
-            }
-            case 'sql native': {
-                return td.rawType
-                    ? { type: 'sql native', rawType: td.rawType }
-                    : { type: 'sql native' };
-            }
-            case 'timestamp': {
-                return {
-                    type: 'timestamp',
-                    ...(td.timeframe === undefined ? {} : { timeframe: td.timeframe }),
-                };
-            }
-            case 'timestamptz': {
-                return {
-                    type: 'timestamptz',
-                    ...(td.timeframe === undefined ? {} : { timeframe: td.timeframe }),
-                };
-            }
-            default:
-                return { type: td.type };
-        }
-    }
-    return { type: 'error' };
+    return model_1.TD.atomicDef(td);
 }
 function parameterTypeDesc(p, evalSpace) {
     const t = p.type;
@@ -177,7 +135,6 @@ function parameterTypeDesc(p, evalSpace) {
         ...theType,
         expressionType: 'scalar',
         evalSpace,
-        fieldUsage: [],
     };
 }
 //# sourceMappingURL=typedesc-utils.js.map

package/dist/lang/ast/types/expr-value.js

@@ -37,7 +37,7 @@ function computedExprValue({ value, dataType, from, }) {
         value,
         expressionType: (0, model_1.maxOfExpressionTypes)(from.map(e => e.expressionType)),
         evalSpace: (0, model_1.mergeEvalSpaces)(...from.map(e => e.evalSpace)),
-        fieldUsage: (0, composite_source_utils_1.mergeFieldUsage)(...from.map(e => e.fieldUsage)),
+        refSummary: (0, composite_source_utils_1.mergeRefSummaries)(...from.map(e => e.refSummary)),
         ungroupings: mergeUngroupings(...from.map(e => e.ungroupings)),
         requiresGroupBy: mergeGroupedBys(...from.map(e => e.requiresGroupBy)),
     };
@@ -49,7 +49,7 @@ function computedTimeResult({ value, dataType, from, timeframe, }) {
         expressionType: xv.expressionType,
         evalSpace: xv.evalSpace,
         value: xv.value,
-        fieldUsage: (0, composite_source_utils_1.mergeFieldUsage)(...from.map(e => e.fieldUsage)),
+        refSummary: (0, composite_source_utils_1.mergeRefSummaries)(...from.map(e => e.refSummary)),
         ungroupings: mergeUngroupings(...from.map(e => e.ungroupings)),
         requiresGroupBy: mergeGroupedBys(...from.map(e => e.requiresGroupBy)),
     };
@@ -76,7 +76,6 @@ function literalTimeResult({ value, dataType, timeframe, }) {
         expressionType: xv.expressionType,
         evalSpace: xv.evalSpace,
         value: xv.value,
-        fieldUsage: [],
     };
     if (timeframe) {
         y.timeframe = timeframe;

package/dist/lang/ast/types/expression-def.d.ts

@@ -27,7 +27,7 @@ export declare abstract class ExpressionDef extends MalloyElement {
      * @param space Namespace for looking up field references
      */
     abstract getExpression(fs: FieldSpace): ExprValue;
-    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
     /**
      * Some operators want to give the right hand value a chance to
      * rewrite itself. This requests a translation for a rewrite,
@@ -66,7 +66,7 @@ export declare class ExprDuration extends ExpressionDef {
     readonly n: ExpressionDef;
     readonly timeframe: TimestampUnit;
     elementType: string;
-    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
     constructor(n: ExpressionDef, timeframe: TimestampUnit);
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
     getExpression(fs: FieldSpace): ExprValue;

package/dist/lang/ast/types/expression-def.js

@@ -296,8 +296,8 @@ function equality(fs, left, op, right) {
             while (actualFilter.node === '()') {
                 actualFilter = actualFilter.e;
             }
-            if (actualFilter.node !== 'parameter') {
-                // Parameters are checked when parameter value is parsed
+            if (actualFilter.node !== 'parameter' && actualFilter.node !== 'given') {
+                // Parameter and given values are checked when supplied
                 checkFilterExpression(right, lhs.type, actualFilter);
             }
             const filterMatch = {

package/dist/lang/ast/types/malloy-element.d.ts

@@ -1,4 +1,4 @@
-import type { Annotation, DocumentLocation, DocumentReference, ModelDef, ModelAnnotation, NamedModelObject, Query, SourceID, SourceRegistryValue, StructDef } from '../../../model/malloy_types';
+import type { Annotation, DocumentLocation, DocumentReference, Given, ModelDef, ModelAnnotation, NamedModelObject, Query, SourceID, SourceRegistryValue, StructDef } from '../../../model/malloy_types';
 import { Tag } from '@malloydata/malloy-tag';
 import type { LogMessageOptions, MessageLogger, MessageParameterType, MessageCode } from '../../parse-log';
 import type { MalloyTranslation } from '../../parse-malloy';
@@ -55,7 +55,7 @@ export declare abstract class MalloyElement {
     toString(): string;
     private stringify;
     walk(): Generator<MalloyElement>;
-    private varInfo;
+    protected varInfo(): string;
     protected internalError(msg: string): Error;
     needs(doc: Document): ModelDataRequest | undefined;
     inExperiment(experimentId: string, silent?: boolean): boolean;
@@ -104,24 +104,12 @@ export declare class DocStatementList extends ListOf<DocStatement | DocStatement
     noteCursor: number;
     executeList(doc: Document): ModelDataRequest;
 }
-/**
- * The Document class is a little weird because we might need to bounce back
- * to the requestor, which might be on the other side of a wire, to get
- * back some schema information. The intended translation of a Document
- * is to call initModelDef(), and then to call modelDataRequest() until it
- * returns undefined. At any time you can call modelDef to get the model
- * as it exists so far, but the translation is not complete until
- * modelDataRequest() returns undefined;
- *
- * TODO probably modelRequest should be the method and you call it
- * until it returns a model with no additional data needed ...
- * that can be tomorrow
- */
 export declare class Document extends MalloyElement implements NameSpace {
     elementType: string;
     globalNameSpace: NameSpace;
     documentModel: Map<string, ModelEntry>;
     documentSrcRegistry: Record<SourceID, SourceRegistryValue>;
+    documentGivens: Map<string, Given>;
     queryList: Query[];
     statements: DocStatementList;
     didInitModel: boolean;
@@ -133,6 +121,8 @@ export declare class Document extends MalloyElement implements NameSpace {
     compile(): DocumentCompileResult;
     private modelAnnotationTodoList;
     rememberToAddModelAnnotations(sd: StructDef): void;
+    private checkGivenAliasCollisions;
+    private checkQueryGivenSatisfiability;
     hasAnnotation(): boolean;
     currentModelAnnotation(): ModelAnnotation | undefined;
     modelDef(): ModelDef;

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

@@ -432,6 +432,20 @@ function annotationID(a) {
  * until it returns a model with no additional data needed ...
  * that can be tomorrow
  */
+function unsatisfiedGivenMessage(label, decl, id) {
+    var _a, _b;
+    // We always have the GivenID; we may or may not have the declaration
+    // (we should — every given referenced should have been copied into
+    // documentGivens at import time — but defend against it being absent).
+    const surface = (_a = decl === null || decl === void 0 ? void 0 : decl.name) !== null && _a !== void 0 ? _a : id;
+    const where = ((_b = decl === null || decl === void 0 ? void 0 : decl.location) === null || _b === void 0 ? void 0 : _b.url)
+        ? ` (declared in ${decl.location.url})`
+        : '';
+    return (`${label} references given \`${surface}\`${where}, ` +
+        'which is not surfaced in this model and has no default. ' +
+        `Either import it (e.g. \`import { ${surface} } from "..."\`) ` +
+        'or supply a default at the declaration site.');
+}
 class Document extends MalloyElement {
     constructor(statements) {
         super();
@@ -439,6 +453,7 @@ class Document extends MalloyElement {
         this.globalNameSpace = new global_name_space_1.GlobalNameSpace();
         this.documentModel = new Map();
         this.documentSrcRegistry = {};
+        this.documentGivens = new Map();
         this.queryList = [];
         this.didInitModel = false;
         this.modelWasModified = false;
@@ -455,6 +470,7 @@ class Document extends MalloyElement {
         }
         this.documentModel = new Map();
         this.documentSrcRegistry = {};
+        this.documentGivens = new Map();
         this.queryList = [];
         if (extendingModelDef) {
             if (extendingModelDef.annotation) {
@@ -465,11 +481,17 @@ class Document extends MalloyElement {
                 if ((0, malloy_types_1.isSourceDef)(entry) ||
                     entry.type === 'query' ||
                     entry.type === 'function' ||
-                    entry.type === 'userType') {
+                    entry.type === 'userType' ||
+                    entry.type === 'given') {
                     const exported = extendingModelDef.exports.includes(nm);
                     this.setEntry(nm, { entry, exported });
                 }
             }
+            if (extendingModelDef.givens) {
+                for (const [id, given] of Object.entries(extendingModelDef.givens)) {
+                    this.documentGivens.set(id, given);
+                }
+            }
         }
         this.didInitModel = true;
     }
@@ -477,6 +499,8 @@ class Document extends MalloyElement {
         const needs = this.statements.executeList(this);
         const modelDef = this.modelDef();
         if (needs === undefined) {
+            this.checkGivenAliasCollisions();
+            this.checkQueryGivenSatisfiability();
             for (const q of this.queryList) {
                 if (q.modelAnnotation === undefined && modelDef.annotation) {
                     q.modelAnnotation = modelDef.annotation;
@@ -501,6 +525,82 @@ class Document extends MalloyElement {
     rememberToAddModelAnnotations(sd) {
         this.modelAnnotationTodoList.push(sd);
     }
+    checkGivenAliasCollisions() {
+        var _a, _b;
+        const byId = new Map();
+        for (const [name, m] of this.documentModel) {
+            if (m.entry.type !== 'given')
+                continue;
+            const list = byId.get(m.entry.id);
+            if (list) {
+                list.push(name);
+            }
+            else {
+                byId.set(m.entry.id, [name]);
+            }
+        }
+        for (const [id, names] of byId) {
+            if (names.length < 2)
+                continue;
+            const decl = this.documentGivens.get(id);
+            const sourceName = (_a = decl === null || decl === void 0 ? void 0 : decl.name) !== null && _a !== void 0 ? _a : names[0];
+            const where = ((_b = decl === null || decl === void 0 ? void 0 : decl.location) === null || _b === void 0 ? void 0 : _b.url)
+                ? ` (declared in ${decl.location.url})`
+                : '';
+            const sorted = [...names].sort();
+            this.logError('given-alias-collision', `Given \`${sourceName}\`${where} is surfaced under multiple names ` +
+                `[${sorted.join(', ')}] in this model. ` +
+                'Surfacing the same given under two names is ambiguous at supply ' +
+                'time. To expose it under a second name, declare a local given ' +
+                `with a default-chain reference: \`given: NEW_NAME :: T is $${sourceName}\`.`);
+        }
+    }
+    checkQueryGivenSatisfiability() {
+        // Always runs at end-of-compile, not gated on imports — a notebook cell
+        // that calls `extendModel` with a prior modelDef inherits that model's
+        // queries and givens, and a query inherited from cell N can become
+        // unsatisfiable in cell N+1 if the satisfying given is removed (or
+        // never re-supplied). Cheap when there's nothing to check.
+        const namespaceGivens = new Set();
+        for (const m of this.documentModel.values()) {
+            if (m.entry.type === 'given')
+                namespaceGivens.add(m.entry.id);
+        }
+        const checkOne = (q, label) => {
+            var _a;
+            const usage = q.givenUsage;
+            if (!usage || usage.length === 0)
+                return;
+            // Build the full set of ids the query transitively needs: each id
+            // in Q.givenUsage, plus each id's precomputed default-chain closure
+            // (Given.givenUsage). Since the closure is already transitive, no
+            // recursion at check time.
+            const allIds = new Set();
+            for (const g of usage) {
+                allIds.add(g.id);
+                const decl = this.documentGivens.get(g.id);
+                for (const t of (_a = decl === null || decl === void 0 ? void 0 : decl.givenUsage) !== null && _a !== void 0 ? _a : [])
+                    allIds.add(t.id);
+            }
+            for (const id of allIds) {
+                if (namespaceGivens.has(id))
+                    continue;
+                const decl = this.documentGivens.get(id);
+                if ((decl === null || decl === void 0 ? void 0 : decl.default) !== undefined)
+                    continue;
+                this.logError('unsatisfied-given-in-query', unsatisfiedGivenMessage(label, decl, id), { at: q.location });
+            }
+        };
+        // Named queries in the namespace (locally defined OR imported).
+        for (const [name, m] of this.documentModel) {
+            if (m.entry.type === 'query')
+                checkOne(m.entry, `Query '${name}'`);
+        }
+        // `run:` statements.
+        for (const q of this.queryList) {
+            checkOne(q, 'run: statement');
+        }
+    }
     hasAnnotation() {
         return ((this.annotation.notes && this.annotation.notes.length > 0) ||
             this.annotation.inherits !== undefined);
@@ -536,9 +636,21 @@ class Document extends MalloyElement {
                     def.contents[name] = newEntry;
                 }
             }
+            else if (entryDef.type === 'given') {
+                if (modelEntry.exported) {
+                    def.exports.push(name);
+                }
+                def.contents[name] = { ...entryDef };
+            }
         }
         // Copy the accumulated sourceRegistry
         def.sourceRegistry = { ...this.documentSrcRegistry };
+        if (this.documentGivens.size > 0) {
+            def.givens = {};
+            for (const [id, given] of this.documentGivens) {
+                def.givens[id] = given;
+            }
+        }
         return def;
     }
     getEntry(str) {