@malloydata/malloy 0.0.398 → 0.0.400

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

@@ -1,11 +1,11 @@
-import type { Annotation, DocumentLocation, FieldDef } from '../../../model/malloy_types';
+import type { AnnotationsDef, DocumentLocation, FieldDef } from '../../../model/malloy_types';
 import { SpaceField } from '../types/space-field';
 export declare class RenameSpaceField extends SpaceField {
     private readonly otherField;
     private readonly newName;
     private readonly location;
     private note;
-    constructor(otherField: SpaceField, newName: string, location: DocumentLocation, note: Annotation | undefined);
+    constructor(otherField: SpaceField, newName: string, location: DocumentLocation, note: AnnotationsDef | undefined);
     fieldDef(): FieldDef | undefined;
     typeDesc(): import("../../..").TypeDesc;
 }

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

@@ -39,14 +39,14 @@ class RenameSpaceField extends space_field_1.SpaceField {
             return undefined;
         }
         if (this.note) {
-            if (returnFieldDef.annotation) {
-                returnFieldDef.annotation = {
+            if (returnFieldDef.annotations) {
+                returnFieldDef.annotations = {
                     ...this.note,
-                    inherits: returnFieldDef.annotation,
+                    inherits: returnFieldDef.annotations,
                 };
             }
             else {
-                returnFieldDef.annotation = this.note;
+                returnFieldDef.annotations = this.note;
             }
         }
         return {

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

@@ -143,7 +143,7 @@ class StaticSpace {
                         : 'fieldReference',
                     definition: {
                         type: definition.type,
-                        annotation: definition.annotation,
+                        annotations: definition.annotations,
                         location: definition.location,
                     },
                     location: head.location,

package/dist/lang/ast/index.d.ts

@@ -67,6 +67,7 @@ export * from './expressions/range';
 export * from './expressions/time-frame';
 export * from './expressions/unary';
 export * from './statements/import-statement';
+export * from './statements/export-statement';
 export * from './query-properties/extend';
 export * from './parameters/argument';
 export * from './parameters/has-parameter';

package/dist/lang/ast/index.js

@@ -105,6 +105,7 @@ __exportStar(require("./expressions/range"), exports);
 __exportStar(require("./expressions/time-frame"), exports);
 __exportStar(require("./expressions/unary"), exports);
 __exportStar(require("./statements/import-statement"), exports);
+__exportStar(require("./statements/export-statement"), exports);
 __exportStar(require("./query-properties/extend"), exports);
 __exportStar(require("./parameters/argument"), exports);
 __exportStar(require("./parameters/has-parameter"), exports);

package/dist/lang/ast/query-elements/anonymous-query.d.ts

@@ -1,4 +1,4 @@
-import type { Annotation } from '../../../model';
+import type { AnnotationsDef } from '../../../model';
 import type { DocStatement, Document } from '../types/malloy-element';
 import { MalloyElement } from '../types/malloy-element';
 import type { Noteable } from '../types/noteable';
@@ -10,6 +10,6 @@ export declare class AnonymousQuery extends MalloyElement implements DocStatemen
     constructor(queryExpr: SourceQueryElement);
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    note?: Annotation;
+    note?: AnnotationsDef;
     execute(doc: Document): void;
 }

package/dist/lang/ast/query-elements/anonymous-query.js

@@ -42,11 +42,11 @@ class AnonymousQuery extends malloy_element_1.MalloyElement {
         }
         const modelQuery = { ...queryObj.query() };
         const annotation = this.note || {};
-        if (modelQuery.annotation) {
-            annotation.inherits = modelQuery.annotation;
+        if (modelQuery.annotations) {
+            annotation.inherits = modelQuery.annotations;
         }
         if (annotation.notes || annotation.blockNotes || annotation.inherits) {
-            modelQuery.annotation = annotation;
+            modelQuery.annotations = annotation;
         }
         doc.queryList.push(modelQuery);
     }

package/dist/lang/ast/query-elements/query-arrow.js

@@ -69,11 +69,11 @@ class QueryArrow extends query_base_1.QueryBase {
             inputStruct = lhsQuery.outputStruct;
             fieldSpace = new static_space_1.StaticSourceSpace(lhsQuery.outputStruct, 'public');
         }
-        const { pipeline: rhsPipeline, annotation, outputStruct, name, } = this.view.pipelineComp(fieldSpace);
+        const { pipeline: rhsPipeline, annotations, outputStruct, name, } = this.view.pipelineComp(fieldSpace);
         const query = {
             ...queryBase,
             name,
-            annotation,
+            annotations,
             pipeline: [...queryBase.pipeline, ...rhsPipeline],
         };
         const compositeResolvedSourceDef = (_a = query.compositeResolvedSourceDef) !== null && _a !== void 0 ? _a : this.resolveCompositeSource(inputStruct, rhsPipeline);

package/dist/lang/ast/query-items/field-declaration.d.ts

@@ -1,4 +1,4 @@
-import type { Annotation, TypeDesc, FieldDef, AtomicFieldDef } from '../../../model/malloy_types';
+import type { AnnotationsDef, TypeDesc, FieldDef, AtomicFieldDef } from '../../../model/malloy_types';
 import type { ExprValue } from '../types/expr-value';
 import type { ExpressionDef } from '../types/expression-def';
 import type { FieldSpace } from '../types/field-space';
@@ -15,7 +15,7 @@ export declare abstract class AtomicFieldDeclaration extends MalloyElement imple
     readonly exprSrc?: string | undefined;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    note?: Annotation;
+    note?: AnnotationsDef;
     constructor(expr: ExpressionDef, defineName: string, exprSrc?: string | undefined);
     getName(): string;
     fieldDef(fs: FieldSpace, exprName: string): FieldDef;

package/dist/lang/ast/query-items/field-declaration.js

@@ -157,7 +157,7 @@ class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
                 ret.code = this.exprSrc;
             }
             if (this.note) {
-                ret.annotation = this.note;
+                ret.annotations = this.note;
             }
             return ret;
         }

package/dist/lang/ast/query-items/field-references.d.ts

@@ -1,4 +1,4 @@
-import type { Annotation, FieldDef, RefToField, TypeDesc } from '../../../model/malloy_types';
+import type { AnnotationsDef, FieldDef, RefToField, TypeDesc } from '../../../model/malloy_types';
 import type { DynamicSpace } from '../field-space/dynamic-space';
 import { DefinitionList } from '../types/definition-list';
 import type { FieldName, FieldSpace } from '../types/field-space';
@@ -10,7 +10,7 @@ import type { MakeEntry } from '../types/space-entry';
 export type FieldReferenceConstructor = new (names: FieldName[]) => FieldReference;
 export declare abstract class FieldReference extends ListOf<FieldName> implements Noteable, MakeEntry {
     readonly isNoteableObj = true;
-    note?: Annotation;
+    note?: AnnotationsDef;
     extendNote: typeof extendNoteMethod;
     constructor(names: FieldName[]);
     makeEntry(fs: DynamicSpace): void;
@@ -97,7 +97,7 @@ export declare class ViewOrScalarFieldReference extends FieldReference {
 export declare class WildcardFieldReference extends MalloyElement implements Noteable {
     readonly joinPath: FieldReference | undefined;
     elementType: string;
-    note?: Annotation;
+    note?: AnnotationsDef;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
     except: Set<string>;

package/dist/lang/ast/query-properties/nest.js

@@ -76,7 +76,7 @@ class NestFieldDeclaration extends view_field_declaration_1.ViewFieldDeclaration
         if (this.turtleDef)
             return this.turtleDef;
         if (fs.isQueryFieldSpace()) {
-            const { pipeline, annotation } = this.view.pipelineComp(fs, fs.outputSpace());
+            const { pipeline, annotations } = this.view.pipelineComp(fs, fs.outputSpace());
             const refSummary = pipeline[0] && model.isQuerySegment(pipeline[0])
                 ? pipeline[0].refSummary
                 : undefined;
@@ -86,7 +86,7 @@ class NestFieldDeclaration extends view_field_declaration_1.ViewFieldDeclaration
                 type: 'turtle',
                 name: this.name,
                 pipeline: pipelineWithDrillPaths,
-                annotation: { ...this.note, inherits: annotation },
+                annotations: { ...this.note, inherits: annotations },
                 location: this.location,
                 refSummary,
             };

package/dist/lang/ast/source-elements/composite-source.d.ts

@@ -1,4 +1,4 @@
-import type { Annotation, SourceDef } from '../../../model/malloy_types';
+import type { AnnotationsDef, SourceDef } from '../../../model/malloy_types';
 import type { HasParameter } from '../parameters/has-parameter';
 import { Source } from './source';
 import type { ParameterSpace } from '../field-space/parameter-space';
@@ -9,7 +9,7 @@ import type { ParameterSpace } from '../field-space/parameter-space';
 export declare class CompositeSource extends Source {
     readonly sources: Source[];
     elementType: string;
-    currentAnnotation?: Annotation;
+    currentAnnotation?: AnnotationsDef;
     constructor(sources: Source[]);
     getSourceDef(parameterSpace: ParameterSpace | undefined): SourceDef;
     withParameters(parameterSpace: ParameterSpace | undefined, pList: HasParameter[] | undefined): SourceDef;

package/dist/lang/ast/source-elements/refined-source.d.ts

@@ -1,4 +1,4 @@
-import type { Annotation, SourceDef } from '../../../model/malloy_types';
+import type { AnnotationsDef, SourceDef } from '../../../model/malloy_types';
 import type { HasParameter } from '../parameters/has-parameter';
 import type { SourceDesc } from '../types/source-desc';
 import { Source } from './source';
@@ -12,7 +12,7 @@ export declare class RefinedSource extends Source {
     readonly refinement: SourceDesc;
     readonly includeList: IncludeItem[] | undefined;
     elementType: string;
-    currentAnnotation?: Annotation;
+    currentAnnotation?: AnnotationsDef;
     constructor(source: Source, refinement: SourceDesc, includeList: IncludeItem[] | undefined);
     getSourceDef(parameterSpace: ParameterSpace | undefined): SourceDef;
     withParameters(parameterSpace: ParameterSpace | undefined, pList: HasParameter[] | undefined): SourceDef;

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

@@ -149,7 +149,7 @@ class SQLSource extends source_1.Source {
             const fromDoc = this.document();
             const modelAnnotation = fromDoc === null || fromDoc === void 0 ? void 0 : fromDoc.currentModelAnnotation();
             if (modelAnnotation) {
-                locStruct.modelAnnotation = modelAnnotation;
+                locStruct.modelAnnotations = modelAnnotation;
             }
             return locStruct;
         }

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

@@ -80,11 +80,14 @@ class TypedSource extends source_1.Source {
                     ? { ...f, accessModifier: exports.USER_TYPE_HIDDEN_ACCESS }
                     : f;
             }
-            const shapeAnnotation = shapeEntry.field.annotation;
+            const shapeAnnotation = shapeEntry.field.annotations;
             if (!shapeAnnotation) {
                 return f;
             }
-            return { ...f, annotation: mergeAnnotation(f.annotation, shapeAnnotation) };
+            return {
+                ...f,
+                annotations: mergeAnnotation(f.annotations, shapeAnnotation),
+            };
         });
         return {
             ...sourceDef,
@@ -105,8 +108,8 @@ class TypedSource extends source_1.Source {
             }
             for (const sf of entry.entry.fields) {
                 const field = (0, malloy_types_1.mkFieldDef)(sf.typeDef, sf.name);
-                if (sf.annotation) {
-                    field.annotation = sf.annotation;
+                if (sf.annotations) {
+                    field.annotations = sf.annotations;
                 }
                 next.set(sf.name, { field, fromShape: ref });
             }

package/dist/lang/ast/source-properties/join.d.ts

@@ -1,4 +1,4 @@
-import type { Annotation, JoinFieldDef, JoinType, MatrixOperation, SourceDef, AccessModifierLabel } from '../../../model/malloy_types';
+import type { AnnotationsDef, JoinFieldDef, JoinType, MatrixOperation, SourceDef, AccessModifierLabel } from '../../../model/malloy_types';
 import type { DynamicSpace } from '../field-space/dynamic-space';
 import { DefinitionList } from '../types/definition-list';
 import type { QueryBuilder } from '../types/query-builder';
@@ -20,7 +20,7 @@ export declare abstract class Join extends MalloyElement implements Noteable, Ma
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
     abstract sourceExpr: SourceQueryElement;
-    note?: Annotation;
+    note?: AnnotationsDef;
     makeEntry(fs: DynamicSpace): void;
     getName(): string;
     protected getStructDefFromExpr(parameterSpace: ParameterSpace): SourceDef;

package/dist/lang/ast/source-properties/join.js

@@ -77,7 +77,7 @@ class KeyJoin extends Join {
         };
         delete joinStruct.as;
         if (this.note) {
-            joinStruct.annotation = this.note;
+            joinStruct.annotations = this.note;
         }
         (_a = this.document()) === null || _a === void 0 ? void 0 : _a.rememberToAddModelAnnotations(joinStruct);
         return joinStruct;
@@ -172,7 +172,7 @@ class ExpressionJoin extends Join {
         };
         delete joinStruct.as;
         if (this.note) {
-            joinStruct.annotation = this.note;
+            joinStruct.annotations = this.note;
         }
         (_a = this.document()) === null || _a === void 0 ? void 0 : _a.rememberToAddModelAnnotations(joinStruct);
         return joinStruct;

package/dist/lang/ast/source-properties/renames.d.ts

@@ -1,4 +1,4 @@
-import type { AccessModifierLabel, Annotation } from '../../../model';
+import type { AccessModifierLabel, AnnotationsDef } from '../../../model';
 import type { DynamicSpace } from '../field-space/dynamic-space';
 import { DefinitionList } from '../types/definition-list';
 import type { FieldName } from '../types/field-space';
@@ -9,7 +9,7 @@ export declare class RenameField extends MalloyElement implements Noteable, Make
     readonly newName: string;
     readonly oldName: FieldName;
     elementType: string;
-    note?: Annotation;
+    note?: AnnotationsDef;
     extendNote: typeof extendNoteMethod;
     readonly isNoteableObj = true;
     constructor(newName: string, oldName: FieldName);

package/dist/lang/ast/source-properties/user-type-shape.d.ts

@@ -1,4 +1,4 @@
-import type { Annotation, AtomicTypeDef, UserTypeFieldDef } from '../../../model/malloy_types';
+import type { AnnotationsDef, AtomicTypeDef, UserTypeFieldDef } from '../../../model/malloy_types';
 import { ListOf, MalloyElement } from '../types/malloy-element';
 import type { Noteable } from '../types/noteable';
 import { extendNoteMethod } from '../types/noteable';
@@ -6,7 +6,7 @@ export declare abstract class UserTypeMember extends MalloyElement implements No
     readonly name: string;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    note?: Annotation;
+    note?: AnnotationsDef;
     constructor(name: string);
     abstract userTypeFieldDef(): UserTypeFieldDef;
 }

package/dist/lang/ast/source-properties/user-type-shape.js

@@ -29,7 +29,7 @@ class UserTypeMemberDef extends UserTypeMember {
             typeDef: this.typeDef,
         };
         if (this.note) {
-            field.annotation = this.note;
+            field.annotations = this.note;
         }
         return field;
     }
@@ -62,8 +62,8 @@ class UserTypeMemberIndirect extends UserTypeMember {
         }
         const fieldsFromReferencedType = modelEntry.entry.fields.map(f => {
             const field = (0, malloy_types_1.mkFieldDef)(f.typeDef, f.name);
-            if (f.annotation) {
-                field.annotation = f.annotation;
+            if (f.annotations) {
+                field.annotations = f.annotations;
             }
             return field;
         });
@@ -76,12 +76,12 @@ class UserTypeMemberIndirect extends UserTypeMember {
         }
         const field = { name: this.name, typeDef };
         if (this.note) {
-            field.annotation = modelEntry.entry.annotation
-                ? { ...this.note, inherits: modelEntry.entry.annotation }
+            field.annotations = modelEntry.entry.annotations
+                ? { ...this.note, inherits: modelEntry.entry.annotations }
                 : this.note;
         }
-        else if (modelEntry.entry.annotation) {
-            field.annotation = { inherits: modelEntry.entry.annotation };
+        else if (modelEntry.entry.annotations) {
+            field.annotations = { inherits: modelEntry.entry.annotations };
         }
         return field;
     }

package/dist/lang/ast/source-properties/view-field-declaration.d.ts

@@ -12,7 +12,7 @@ export declare class ViewFieldDeclaration extends MalloyElement implements Notea
     elementType: string;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    note?: model.Annotation;
+    note?: model.AnnotationsDef;
     constructor(name: string, view: View);
     makeEntry(fs: DynamicSpace): void;
     getName(): string;

package/dist/lang/ast/source-properties/view-field-declaration.js

@@ -44,13 +44,13 @@ class ViewFieldDeclaration extends malloy_element_1.MalloyElement {
         return this.name;
     }
     getFieldDef(fs) {
-        const { pipeline, annotation } = this.view.pipelineComp(fs);
+        const { pipeline, annotations } = this.view.pipelineComp(fs);
         const checkedPipeline = (0, query_utils_1.detectAndRemovePartialStages)(pipeline, this);
         const def = {
             type: 'turtle',
             name: this.name,
             pipeline: checkedPipeline,
-            annotation: { ...this.note, inherits: annotation },
+            annotations: { ...this.note, inherits: annotations },
             location: this.location,
         };
         return def;

package/dist/lang/ast/source-query-elements/include-item.d.ts

@@ -1,6 +1,6 @@
 import { MalloyElement } from '../types/malloy-element';
 import type { AccessModifierFieldReference, FieldReference, WildcardFieldReference } from '../query-items/field-references';
-import type { Annotation } from '../../../model';
+import type { AnnotationsDef } from '../../../model';
 import type { Noteable } from '../types/noteable';
 import { extendNoteMethod } from '../types/noteable';
 export declare abstract class IncludeItem extends MalloyElement {
@@ -12,7 +12,7 @@ export declare class IncludeAccessItem extends IncludeItem implements Noteable {
     elementType: string;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    note?: Annotation;
+    note?: AnnotationsDef;
     constructor(kind: 'private' | 'public' | 'internal' | undefined, fields: IncludeListItem[]);
 }
 export declare class IncludeExceptItem extends IncludeItem {
@@ -27,6 +27,6 @@ export declare class IncludeListItem extends MalloyElement implements Noteable {
     elementType: string;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    note?: Annotation;
+    note?: AnnotationsDef;
     constructor(name: AccessModifierFieldReference | WildcardFieldReference, as: string | undefined);
 }

package/dist/lang/ast/statements/define-given.d.ts

@@ -1,4 +1,4 @@
-import type { Annotation, GivenTypeDef } from '../../../model/malloy_types';
+import type { AnnotationsDef, GivenTypeDef } from '../../../model/malloy_types';
 import type { ConstantExpression } from '../expressions/constant-expression';
 import type { DocStatement, Document } from '../types/malloy-element';
 import { DocStatementList, MalloyElement } from '../types/malloy-element';
@@ -11,7 +11,7 @@ export declare class GivenDeclaration extends MalloyElement implements DocStatem
     elementType: string;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    note?: Annotation;
+    note?: AnnotationsDef;
     readonly default?: ConstantExpression;
     constructor(name: string, typeDef: GivenTypeDef, defaultExpr?: ConstantExpression, inline?: boolean);
     protected varInfo(): string;

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

@@ -173,7 +173,7 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
             defaultText,
             givenUsage,
             location: this.location,
-            annotation: this.note,
+            annotations: this.note,
             ...(this.inline ? { inline: true } : {}),
         };
         doc.documentGivens.set(id, givenIR);
@@ -195,7 +195,7 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
             },
             definition: {
                 type: (0, utils_1.typeDefToString)(this.typeDef),
-                annotation: this.note,
+                annotations: this.note,
                 location: this.location,
                 defaultText,
             },

package/dist/lang/ast/statements/define-query.d.ts

@@ -1,4 +1,4 @@
-import type { Annotation } from '../../../model/malloy_types';
+import type { AnnotationsDef } from '../../../model/malloy_types';
 import type { DocStatement, Document } from '../types/malloy-element';
 import { MalloyElement, DocStatementList } from '../types/malloy-element';
 import type { Noteable } from '../types/noteable';
@@ -11,7 +11,7 @@ export declare class DefineQuery extends MalloyElement implements DocStatement,
     constructor(name: string, queryExpr: SourceQueryElement);
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    note?: Annotation;
+    note?: AnnotationsDef;
     execute(doc: Document): void;
 }
 export declare class DefineQueryList extends DocStatementList {

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

@@ -52,8 +52,8 @@ class DefineQuery extends malloy_element_1.MalloyElement {
             location: this.location,
         };
         if (this.note) {
-            entry.annotation = entry.annotation
-                ? { ...this.note, inherits: entry.annotation }
+            entry.annotations = entry.annotations
+                ? { ...this.note, inherits: entry.annotations }
                 : this.note;
         }
         doc.setEntry(this.name, { entry, exported: true });

package/dist/lang/ast/statements/define-source.d.ts

@@ -1,4 +1,4 @@
-import type { Annotation } from '../../../model/malloy_types';
+import type { AnnotationsDef } from '../../../model/malloy_types';
 import type { HasParameter } from '../parameters/has-parameter';
 import type { DocStatement, Document } from '../types/malloy-element';
 import { MalloyElement, DocStatementList } from '../types/malloy-element';
@@ -14,7 +14,7 @@ export declare class DefineSource extends MalloyElement implements DocStatement,
     constructor(name: string, sourceExpr: SourceQueryElement | undefined, exported: boolean, parameters?: HasParameter[] | undefined);
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    note?: Annotation;
+    note?: AnnotationsDef;
     execute(doc: Document): void;
     private deduplicatedParameters;
     private validateParameterShadowing;

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

@@ -69,8 +69,8 @@ class DefineSource extends malloy_element_1.MalloyElement {
             location: this.location,
         };
         if (this.note) {
-            entry.annotation = structDef.annotation
-                ? { ...this.note, inherits: structDef.annotation }
+            entry.annotations = structDef.annotations
+                ? { ...this.note, inherits: structDef.annotations }
                 : this.note;
         }
         if ((0, malloy_types_1.isPersistableSourceDef)(entry)) {

package/dist/lang/ast/statements/define-user-type.d.ts

@@ -2,7 +2,7 @@ import type { DocStatement, Document } from '../types/malloy-element';
 import { MalloyElement, DocStatementList } from '../types/malloy-element';
 import type { Noteable } from '../types/noteable';
 import { extendNoteMethod } from '../types/noteable';
-import type { Annotation, UserTypeFieldDef } from '../../../model/malloy_types';
+import type { AnnotationsDef, UserTypeFieldDef } from '../../../model/malloy_types';
 import type { UserTypeMember } from '../source-properties/user-type-shape';
 import { UserTypeShape } from '../source-properties/user-type-shape';
 export declare class ExtendedUserTypeShape extends UserTypeShape {
@@ -19,7 +19,7 @@ export declare class DefineUserType extends MalloyElement implements DocStatemen
     constructor(name: string, shapeDef: UserTypeShape, exported: boolean);
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    note?: Annotation;
+    note?: AnnotationsDef;
     execute(doc: Document): void;
 }
 export declare class DefineUserTypeList extends DocStatementList {

package/dist/lang/ast/statements/define-user-type.js

@@ -66,7 +66,7 @@ class DefineUserType extends malloy_element_1.MalloyElement {
             location: this.location,
         };
         if (this.note) {
-            entry.annotation = this.note;
+            entry.annotations = this.note;
         }
         doc.setEntry(this.name, { entry, exported: this.exported });
     }

package/dist/lang/ast/statements/export-statement.d.ts

@@ -0,0 +1,12 @@
+import type { DocStatement, Document } from '../types/malloy-element';
+import { ListOf, MalloyElement } from '../types/malloy-element';
+export declare class ExportItem extends MalloyElement {
+    readonly name: string;
+    elementType: string;
+    constructor(name: string);
+}
+export declare class ExportStatement extends ListOf<ExportItem> implements DocStatement {
+    elementType: string;
+    constructor(items: ExportItem[]);
+    execute(doc: Document): void;
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportStatement = exports.ExportItem = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const malloy_element_1 = require("../types/malloy-element");
+class ExportItem extends malloy_element_1.MalloyElement {
+    constructor(name) {
+        super();
+        this.name = name;
+        this.elementType = 'exportItem';
+    }
+}
+exports.ExportItem = ExportItem;
+class ExportStatement extends malloy_element_1.ListOf {
+    constructor(items) {
+        super(items);
+        this.elementType = 'export statement';
+    }
+    execute(doc) {
+        if (doc.explicitExports === undefined) {
+            doc.explicitExports = new Set();
+        }
+        const explicit = doc.explicitExports;
+        for (const item of this.list) {
+            const name = item.name;
+            if (explicit.has(name)) {
+                item.logError('duplicate-export-name', `'${name}' already appears in an export statement`);
+                continue;
+            }
+            const entry = doc.documentModel.get(name);
+            if (entry === undefined) {
+                item.logError('export-name-not-defined', `Cannot export '${name}': no such definition above this statement`);
+                continue;
+            }
+            const def = entry.entry;
+            const exportable = (0, malloy_types_1.isSourceDef)(def) ||
+                def.type === 'query' ||
+                def.type === 'userType' ||
+                def.type === 'given';
+            if (!exportable) {
+                item.logError('export-name-not-exportable', `Cannot export '${name}': only sources, queries, given declarations, and user types may be exported`);
+                continue;
+            }
+            explicit.add(name);
+        }
+    }
+}
+exports.ExportStatement = ExportStatement;
+//# sourceMappingURL=export-statement.js.map

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

@@ -166,7 +166,7 @@ class ImportStatement extends malloy_element_1.ListOf {
                                             location: importOne.location,
                                             definition: {
                                                 type: (0, utils_1.typeDefToString)(givenIR.type),
-                                                annotation: givenIR.annotation,
+                                                annotations: givenIR.annotations,
                                                 location: givenIR.location,
                                                 defaultText: givenIR.defaultText,
                                             },

package/dist/lang/ast/types/annotation-elements.js

@@ -54,10 +54,10 @@ class ModelAnnotation extends ObjectAnnotation {
                 this.logError('restricted-construct-forbidden', `\`${line}\` cannot be used in a restricted query — compiler-flag annotations are not permitted.`, { at: note.at });
             }
         }
-        if (doc.annotation.notes === undefined) {
-            doc.annotation.notes = [];
+        if (doc.annotations.notes === undefined) {
+            doc.annotations.notes = [];
         }
-        doc.annotation.notes.push(...this.notes);
+        doc.annotations.notes.push(...this.notes);
     }
 }
 exports.ModelAnnotation = ModelAnnotation;

package/dist/lang/ast/types/definition-list.d.ts

@@ -1,11 +1,11 @@
-import type { Annotation } from '../../../model';
+import type { AnnotationsDef } from '../../../model';
 import type { MalloyElement } from './malloy-element';
 import { ListOf } from './malloy-element';
 import type { Noteable } from '../types/noteable';
 export declare abstract class DefinitionList<DT extends MalloyElement> extends ListOf<DT> implements Noteable {
     readonly isNoteableObj = true;
-    note?: Annotation;
-    extendNote(ext: Partial<Annotation>): void;
+    note?: AnnotationsDef;
+    extendNote(ext: Partial<AnnotationsDef>): void;
     distributeAnnotation(): void;
     protected newContents(): void;
 }