@malloydata/malloy 0.0.399 → 0.0.401

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/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;
 }

package/dist/lang/ast/types/literal.d.ts

@@ -4,4 +4,4 @@ import { LiteralDay, LiteralHour, LiteralMonth, LiteralTimestamp, LiteralYear }
 import { ExprNumber } from '../expressions/expr-number';
 import type { ExpressionDef } from './expression-def';
 export type Literal = LiteralTimestamp | LiteralHour | LiteralMonth | LiteralDay | LiteralYear | ExprNumber | ExprString | Boolean;
-export declare function isLiteral(value: ExpressionDef): value is ExprString | ExprNumber | Boolean | LiteralTimestamp | LiteralHour | LiteralDay | LiteralMonth | LiteralYear;
+export declare function isLiteral(value: ExpressionDef): value is ExprString | Boolean | LiteralTimestamp | LiteralHour | LiteralDay | LiteralMonth | LiteralYear | ExprNumber;

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

@@ -1,4 +1,4 @@
-import type { Annotation, DocumentLocation, DocumentReference, Given, ModelDef, ModelAnnotation, NamedModelObject, Query, SourceID, SourceRegistryValue, StructDef } from '../../../model/malloy_types';
+import type { AnnotationsDef, DocumentLocation, DocumentReference, Given, ModelDef, ModelAnnotationsDef, 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';
@@ -101,7 +101,7 @@ export declare class DocStatementList extends ListOf<DocStatement | DocStatement
     execCursor: number;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    note?: Annotation;
+    note?: AnnotationsDef;
     noteCursor: number;
     executeList(doc: Document): ModelDataRequest;
 }
@@ -116,7 +116,7 @@ export declare class Document extends MalloyElement implements NameSpace {
     statements: DocStatementList;
     didInitModel: boolean;
     modelWasModified: boolean;
-    annotation: Annotation;
+    annotations: AnnotationsDef;
     experiments: Tag;
     constructor(statements: (DocStatement | DocStatementList)[]);
     initModelDef(extendingModelDef: ModelDef | undefined): void;
@@ -126,7 +126,7 @@ export declare class Document extends MalloyElement implements NameSpace {
     private checkGivenAliasCollisions;
     private checkQueryGivenSatisfiability;
     hasAnnotation(): boolean;
-    currentModelAnnotation(): ModelAnnotation | undefined;
+    currentModelAnnotation(): ModelAnnotationsDef | undefined;
     modelDef(): ModelDef;
     getEntry(str: string): ModelEntry | undefined;
     setEntry(str: string, ent: ModelEntry): void;

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

@@ -121,7 +121,7 @@ class MalloyElement {
                     text: key,
                     definition: {
                         type: result.entry.type,
-                        annotation: result.entry.annotation,
+                        annotations: result.entry.annotations,
                         location: result.entry.location,
                     },
                     location: reference.location,
@@ -133,7 +133,7 @@ class MalloyElement {
                     text: key,
                     definition: {
                         type: result.entry.type,
-                        annotation: result.entry.annotation,
+                        annotations: result.entry.annotations,
                         location: result.entry.location,
                     },
                     location: reference.location,
@@ -463,7 +463,7 @@ class Document extends MalloyElement {
         this.queryList = [];
         this.didInitModel = false;
         this.modelWasModified = false;
-        this.annotation = {};
+        this.annotations = {};
         this.experiments = new malloy_tag_1.Tag({});
         this.modelAnnotationTodoList = [];
         this.dialectNameSpaces = new Map();
@@ -480,8 +480,8 @@ class Document extends MalloyElement {
         this.explicitExports = undefined;
         this.queryList = [];
         if (extendingModelDef) {
-            if (extendingModelDef.annotation) {
-                this.annotation.inherits = extendingModelDef.annotation;
+            if (extendingModelDef.annotations) {
+                this.annotations.inherits = extendingModelDef.annotations;
             }
             for (const [nm, orig] of Object.entries(extendingModelDef.contents)) {
                 const entry = { ...orig };
@@ -509,14 +509,14 @@ class Document extends MalloyElement {
             this.checkGivenAliasCollisions();
             this.checkQueryGivenSatisfiability();
             for (const q of this.queryList) {
-                if (q.modelAnnotation === undefined && modelDef.annotation) {
-                    q.modelAnnotation = modelDef.annotation;
+                if (q.modelAnnotations === undefined && modelDef.annotations) {
+                    q.modelAnnotations = modelDef.annotations;
                 }
             }
         }
-        if (modelDef.annotation) {
+        if (modelDef.annotations) {
             for (const sd of this.modelAnnotationTodoList) {
-                sd.modelAnnotation || (sd.modelAnnotation = modelDef.annotation);
+                sd.modelAnnotations || (sd.modelAnnotations = modelDef.annotations);
             }
         }
         const ret = {
@@ -609,12 +609,12 @@ class Document extends MalloyElement {
         }
     }
     hasAnnotation() {
-        return ((this.annotation.notes && this.annotation.notes.length > 0) ||
-            this.annotation.inherits !== undefined);
+        return ((this.annotations.notes && this.annotations.notes.length > 0) ||
+            this.annotations.inherits !== undefined);
     }
     currentModelAnnotation() {
         if (this.hasAnnotation()) {
-            const ret = { ...this.annotation, id: '' };
+            const ret = { ...this.annotations, id: '' };
             ret.id = annotationID(ret);
             return ret;
         }
@@ -622,7 +622,7 @@ class Document extends MalloyElement {
     modelDef() {
         const def = (0, utils_1.mkModelDef)('');
         if (this.hasAnnotation()) {
-            def.annotation = this.currentModelAnnotation();
+            def.annotations = this.currentModelAnnotation();
         }
         const explicit = this.explicitExports;
         const isExported = (name, modelEntry) => explicit ? explicit.has(name) : modelEntry.exported === true;
@@ -639,8 +639,8 @@ class Document extends MalloyElement {
                 }
                 else {
                     const newEntry = { ...entryDef };
-                    if (newEntry.modelAnnotation === undefined && def.annotation) {
-                        newEntry.modelAnnotation = def.annotation;
+                    if (newEntry.modelAnnotations === undefined && def.annotations) {
+                        newEntry.modelAnnotations = def.annotations;
                     }
                     def.contents[name] = newEntry;
                 }

package/dist/lang/ast/types/noteable.d.ts

@@ -1,12 +1,12 @@
-import type { Annotation } from '../../../model/malloy_types';
+import type { AnnotationsDef } from '../../../model/malloy_types';
 /**
  * An object which can receive annotations is "Noteable"
  */
 export interface Noteable {
     isNoteableObj: true;
-    note?: Annotation;
-    extendNote(ext: Partial<Annotation>): void;
+    note?: AnnotationsDef;
+    extendNote(ext: Partial<AnnotationsDef>): void;
 }
 export declare function isNoteable(el: unknown): el is Noteable;
-export declare function extendNoteMethod(this: Noteable, ext: Partial<Annotation>): void;
-export declare function extendNoteHelper(to: Noteable, ext: Partial<Annotation>): void;
+export declare function extendNoteMethod(this: Noteable, ext: Partial<AnnotationsDef>): void;
+export declare function extendNoteHelper(to: Noteable, ext: Partial<AnnotationsDef>): void;

package/dist/lang/ast/types/pipeline-comp.d.ts

@@ -1,7 +1,7 @@
-import type { Annotation, PipeSegment, SourceDef } from '../../../model/malloy_types';
+import type { AnnotationsDef, PipeSegment, SourceDef } from '../../../model/malloy_types';
 export interface PipelineComp {
     outputStruct: SourceDef;
     pipeline: PipeSegment[];
-    annotation?: Annotation;
+    annotations?: AnnotationsDef;
     name?: string;
 }

package/dist/lang/ast/view-elements/reference-view.js

@@ -123,7 +123,7 @@ class ReferenceView extends view_1.View {
             return {
                 pipeline,
                 name: fieldDef.name,
-                annotation: fieldDef.annotation,
+                annotations: fieldDef.annotations,
                 outputStruct: pipeline[pipeline.length - 1].outputStruct,
             };
         }

package/dist/lang/ast/view-elements/view-refine.js

@@ -44,7 +44,7 @@ class ViewRefine extends view_1.View {
         const resultPipe = this.refinement.refine(fs, query.pipeline, isNestIn);
         return {
             pipeline: resultPipe,
-            annotation: query.annotation,
+            annotations: query.annotations,
             outputStruct: resultPipe.length > 0
                 ? resultPipe[resultPipe.length - 1].outputStruct
                 : error_factory_1.ErrorFactory.structDef,

package/dist/lang/composite-source-utils.d.ts

@@ -1,5 +1,5 @@
 import type { MalloyElement } from './ast';
-import type { FieldUsage, FieldUsageEntry, GivenUsage, PipeSegment, RefSummary, SourceDef, RequiredGroupBy, Annotation, PartitionCompositeDesc, StructDef } from '../model/malloy_types';
+import type { FieldUsage, FieldUsageEntry, GivenUsage, PipeSegment, RefSummary, SourceDef, RequiredGroupBy, AnnotationsDef, PartitionCompositeDesc, StructDef } from '../model/malloy_types';
 type CompositeCouldNotFindFieldError = {
     code: 'could_not_find_field';
     data: {
@@ -51,7 +51,7 @@ interface CompositeFailure {
     issues: CompositeIssue[];
 }
 export declare function getExpandedSegment(segment: PipeSegment, inputSource: SourceDef): PipeSegment;
-export declare function getPartitionCompositeDesc(annotation: Annotation | undefined, structDef: StructDef, logTo: MalloyElement): PartitionCompositeDesc | undefined;
+export declare function getPartitionCompositeDesc(annotations: AnnotationsDef | undefined, structDef: StructDef, logTo: MalloyElement): PartitionCompositeDesc | undefined;
 type SingleNarrowedCompositeFieldResolution = {
     source: SourceDef;
     nested?: SingleNarrowedCompositeFieldResolution | undefined;

package/dist/lang/composite-source-utils.js

@@ -33,7 +33,7 @@ const malloy_filter_1 = require("@malloydata/malloy-filter");
 const malloy_types_1 = require("../model/malloy_types");
 const utils_1 = require("./utils");
 const utils_2 = require("../model/utils");
-const annotation_1 = require("../annotation");
+const annotation_1 = require("../api/foundation/annotation");
 function _resolveCompositeSources(path, source, rootFields, nests, fieldUsage, 
 // for resolving nested composites; the list of sources to try
 sources) {
@@ -115,13 +115,13 @@ sources) {
                 }
                 base = {
                     ...resolveInner.success,
-                    annotation: composeAnnotations(base.annotation, resolveInner.success.annotation),
+                    annotations: composeAnnotations(base.annotations, resolveInner.success.annotations),
                 };
             }
             else {
                 base = {
                     ...inputSource,
-                    annotation: composeAnnotations(base.annotation, inputSource.annotation),
+                    annotations: composeAnnotations(base.annotations, inputSource.annotations),
                 };
             }
             const fields = [...nonCompositeFields, ...base.fields];
@@ -544,10 +544,10 @@ function getPartitionCompositeFilter(partitionComposite, fieldUsage) {
     };
     return { partitionFilter, issues: undefined };
 }
-function getPartitionCompositeDesc(annotation, structDef, logTo) {
-    if (annotation === undefined)
+function getPartitionCompositeDesc(annotations, structDef, logTo) {
+    if (annotations === undefined)
         return undefined;
-    const compilerFlags = new annotation_1.Annotations(annotation).parseAsTag('!').tag;
+    const compilerFlags = new annotation_1.Annotations(annotations).parseAsTag('!').tag;
     const partitionCompositeTag = compilerFlags.tag('experimental', 'partition_composite');
     if (partitionCompositeTag === undefined)
         return undefined;

package/dist/lang/malloy-to-ast.d.ts

@@ -25,7 +25,7 @@ interface IndirectUserType {
     arrayDepth: number;
 }
 type UserTypeFieldTypeResult = AtomicTypeDef | IndirectUserType;
-type HasAnnotations = ParserRuleContext & {
+type AnnotatedCtx = ParserRuleContext & {
     annotation: () => parse.AnnotationContext[];
 };
 /**
@@ -99,7 +99,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
      * malformation marker through the IR and are not re-warned by importers.
      */
     private warnIfMalformedPrefix;
-    protected getNotes(cx: HasAnnotations): Note[];
+    protected getNotes(cx: AnnotatedCtx): Note[];
     protected getIsNotes(cx: parse.IsDefineContext): Note[];
     visitMalloyDocument(pcx: parse.MalloyDocumentContext): ast.Document;
     visitDefineSourceStatement(pcx: parse.DefineSourceStatementContext): ast.DefineSourceList;
@@ -280,7 +280,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitSegRefine(pcx: parse.SegRefineContext): ast.ViewRefine;
     visitVArrow(pcx: parse.VArrowContext): ast.ViewArrow;
     visitSQRefinedQuery(pcx: parse.SQRefinedQueryContext): ast.SQRefine;
-    visitSQTable(pcx: parse.SQTableContext): ErrorNode | ast.SQSource;
+    visitSQTable(pcx: parse.SQTableContext): ast.SQSource | ErrorNode;
     visitSQVirtual(pcx: parse.SQVirtualContext): ast.SQSource;
     visitSQSQL(pcx: parse.SQSQLContext): ast.SQSource;
     visitExperimentalStatementForTesting(pcx: parse.ExperimentalStatementForTestingContext): ast.ExperimentalExperiment;

package/dist/lang/malloy-to-ast.js

@@ -62,7 +62,7 @@ const AbstractParseTreeVisitor_1 = require("antlr4ts/tree/AbstractParseTreeVisit
 const ast = __importStar(require("./ast"));
 const parse_log_1 = require("./parse-log");
 const Interval_1 = require("antlr4ts/misc/Interval");
-const prefix_1 = require("../prefix");
+const annotation_prefix_1 = require("./annotation-prefix");
 const ast_1 = require("./ast");
 const parse_utils_1 = require("./parse-utils");
 const malloy_types_1 = require("../model/malloy_types");
@@ -283,7 +283,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
      * malformation marker through the IR and are not re-warned by importers.
      */
     warnIfMalformedPrefix(text, cx) {
-        const parsed = (0, prefix_1.parsePrefix)(text);
+        const parsed = (0, annotation_prefix_1.parsePrefix)(text);
         if (parsed.malformation === undefined)
             return;
         // The slice up to contentIndex is "prefix + separator"; trim trailing
@@ -1552,7 +1552,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         for (const a of pcx.docAnnotation()) {
             const block = a.docBlockAnnotation();
             if (block && !block.BLOCK_ANNOTATION_END()) {
-                this.contextError(pcx, 'unclosed-block-annotation', 'Block annotation is not closed, add correctly indented "|##"');
+                this.contextError(pcx, 'unclosed-block-annotation', 'Multi-line annotation is not closed, add correctly indented "|##"');
             }
         }
         const allNotes = pcx.docAnnotation().map(a => {
@@ -1570,7 +1570,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
             return block && !block.BLOCK_ANNOTATION_END();
         });
         if (hasUnclosedBlock) {
-            this.contextError(pcx, 'unclosed-block-annotation', 'Block annotation is not closed, add correctly indented "|#"');
+            this.contextError(pcx, 'unclosed-block-annotation', 'Multi-line annotation is not closed, add correctly indented "|#"');
         }
         else {
             this.contextError(pcx, 'orphaned-object-annotation', 'Object annotation not connected to any object');
@@ -1583,7 +1583,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
             return block && !block.BLOCK_ANNOTATION_END();
         });
         if (hasUnclosedBlock) {
-            this.contextError(pcx, 'unclosed-block-annotation', 'Block annotation is not closed, add correctly indented "|##"');
+            this.contextError(pcx, 'unclosed-block-annotation', 'Multi-line annotation is not closed, add correctly indented "|##"');
         }
         else {
             this.contextError(pcx, 'misplaced-model-annotation', 'Model annotations not allowed at this scope');

package/dist/lang/malloy-to-stable-query.d.ts

@@ -8,7 +8,7 @@ import type { LogMessageOptions, MessageCode, MessageLogger, MessageParameterTyp
 import type { DocumentLocation } from '../model/malloy_types';
 import type { ParseInfo } from './utils';
 import type { TimeLiteral } from './ast';
-type HasAnnotations = ParserRuleContext & {
+type AnnotatedCtx = ParserRuleContext & {
     annotation: () => parse.AnnotationContext[];
 };
 type Node = Malloy.Query | Malloy.QueryDefinitionWithArrow | Malloy.QueryDefinitionWithQueryReference | Malloy.QueryDefinitionWithRefinement | null;
@@ -41,7 +41,7 @@ export declare class MalloyToQuery extends AbstractParseTreeVisitor<Node> implem
      * @param cx Any parse context which has an annotation* rule
      * @returns Array of texts for the annotations
      */
-    protected getAnnotations(cx: HasAnnotations): Malloy.Annotation[] | undefined;
+    protected getAnnotations(cx: AnnotatedCtx): Malloy.Annotation[] | undefined;
     protected getIsAnnotations(cx?: parse.IsDefineContext): Malloy.Annotation[] | undefined;
     protected notAllowed(pcx: ParserRuleContext, what: string): void;
     protected illegal(pcx: ParserRuleContext, what: string): void;

package/dist/lang/parse-malloy.js

@@ -72,7 +72,7 @@ const utils_2 = require("./utils");
 const malloy_tag_1 = require("@malloydata/malloy-tag");
 const model_annotation_walker_1 = require("./parse-tree-walkers/model-annotation-walker");
 const find_table_path_walker_1 = require("./parse-tree-walkers/find-table-path-walker");
-const annotation_1 = require("../annotation");
+const annotation_1 = require("../api/foundation/annotation");
 const run_malloy_parser_1 = require("./run-malloy-parser");
 const timing_1 = require("../timing");
 class ParseStep {
@@ -420,11 +420,11 @@ class ModelAnnotationStep {
                 return tryParse;
             }
             else {
-                const modelAnnotation = (0, model_annotation_walker_1.walkForModelAnnotation)(that, tryParse.parse.tokenStream, tryParse.parse);
+                const modelAnnotations = (0, model_annotation_walker_1.walkForModelAnnotation)(that, tryParse.parse.tokenStream, tryParse.parse);
                 this.response = {
-                    modelAnnotation: {
-                        ...modelAnnotation,
-                        inherits: extendingModel === null || extendingModel === void 0 ? void 0 : extendingModel.annotation,
+                    modelAnnotations: {
+                        ...modelAnnotations,
+                        inherits: extendingModel === null || extendingModel === void 0 ? void 0 : extendingModel.annotations,
                     },
                 };
             }
@@ -478,7 +478,7 @@ class TranslateStep {
         // seeding (e.g. TestTranslator's compilerFlags option) survive.
         if (extendingModel && !this.importedAnnotations) {
             const parseCompilerFlagsTimer = new timing_1.Timer('parse_compiler_flags');
-            that.compilerFlagSrc.push(...new annotation_1.Annotations(extendingModel.annotation).texts('!'));
+            that.compilerFlagSrc.push(...new annotation_1.Annotations(extendingModel.annotations).texts('!'));
             stepTimer.contribute([parseCompilerFlagsTimer.stop()]);
             this.importedAnnotations = true;
         }

package/dist/lang/parse-tree-walkers/model-annotation-walker.d.ts

@@ -1,5 +1,5 @@
 import type { CommonTokenStream } from 'antlr4ts';
 import type { MalloyTranslation } from '../parse-malloy';
-import type { Annotation } from '../../model/malloy_types';
+import type { AnnotationsDef } from '../../model/malloy_types';
 import type { MalloyParseInfo } from '../malloy-parse-info';
-export declare function walkForModelAnnotation(forParse: MalloyTranslation, tokens: CommonTokenStream, parseInfo: MalloyParseInfo): Annotation;
+export declare function walkForModelAnnotation(forParse: MalloyTranslation, tokens: CommonTokenStream, parseInfo: MalloyParseInfo): AnnotationsDef;