@malloydata/malloy 0.0.399 → 0.0.400

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;

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

@@ -37,7 +37,7 @@ class ModelAnnotationWalker {
             this.notes.push((0, parse_utils_1.noteFromAnnotation)(a, this.parseInfo));
         }
     }
-    get annotation() {
+    get annotations() {
         return { notes: this.notes };
     }
 }
@@ -45,6 +45,6 @@ function walkForModelAnnotation(forParse, tokens, parseInfo) {
     const finder = new ModelAnnotationWalker(forParse, tokens, parseInfo);
     const listener = finder;
     ParseTreeWalker_1.ParseTreeWalker.DEFAULT.walk(listener, parseInfo.root);
-    return finder.annotation;
+    return finder.annotations;
 }
 //# sourceMappingURL=model-annotation-walker.js.map

package/dist/lang/prettify/index.js

@@ -49,7 +49,7 @@
  *     of a comparison reads as one unit; breaking inside is more confusing
  *     than the line being long.
  *   - SQL strings (`"""…"""`, including `%{…}` malloy interpolations) and
- *     block annotations (`#" … "`) are emitted verbatim from source. We don't
+ *     multi-line annotations (`#" … "`) are emitted verbatim from source. We don't
  *     own a SQL formatter; annotation indentation is significant.
  *   - `;` is the compact-inline statement separator. Wrapped form drops it
  *     (newlines do the job); inline form keeps it.

package/dist/lang/prettify/leaf.js

@@ -164,8 +164,8 @@ function emitVisibleToken(f, t, idx) {
         return; // already emitted (e.g. SQL block range)
     flushHiddenBefore(f, idx);
     const text = (_a = t.text) !== null && _a !== void 0 ? _a : '';
-    // ---- Verbatim regions: SQL strings and block annotations ----
-    // We don't own a SQL formatter. Annotation indentation is significant.
+    // ---- Verbatim regions: SQL strings and multi-line annotations ----
+    // We don't own a SQL formatter. Multi-line annotation indentation is significant.
     if (t.type === tokens_1.L.SQL_BEGIN) {
         const endIdx = (0, tokens_1.findMatching)(f.tokens, idx, tokens_1.L.SQL_BEGIN, tokens_1.L.SQL_END);
         const stop = f.tokens[endIdx].stopIndex;

package/dist/lang/translate-response.d.ts

@@ -1,5 +1,5 @@
 import type * as Malloy from '@malloydata/malloy-interfaces';
-import type { Annotation, ModelDef } from '../model/malloy_types';
+import type { AnnotationsDef, ModelDef } from '../model/malloy_types';
 import type { MalloyElement } from './ast';
 import type { LogMessage } from './parse-log';
 import type { DocumentSymbol } from './parse-tree-walkers/document-symbol-walker';
@@ -55,7 +55,7 @@ interface Metadata extends ResponseBase, NeededData, ProblemResponse, FinalRespo
 }
 export type MetadataResponse = Partial<Metadata>;
 interface ModelAnnotationData extends ResponseBase, NeededData, ProblemResponse, FinalResponse {
-    modelAnnotation: Annotation;
+    modelAnnotations: AnnotationsDef;
 }
 export type ModelAnnotationResponse = Partial<ModelAnnotationData>;
 interface Completions extends ResponseBase, NeededData, ProblemResponse, FinalResponse {

package/dist/model/malloy_types.d.ts

@@ -335,7 +335,7 @@ export type Argument = Parameter;
  * shape here is the conservative "not yet narrowed" version.
  */
 export type GivenTypeDef = AtomicTypeDef | FilterExpressionParamTypeDef;
-export interface Given extends HasLocation, HasAnnotation {
+export interface Given extends HasLocation, HasAnnotations {
     /** The name as written at the declaration site. Used by diagnostics
      *  that need a readable surface name out of an opaque GivenID. */
     name: string;
@@ -396,7 +396,7 @@ export interface DocumentLocation {
  * the references, and in that case, this should include something like an
  * index or pointer to the full definition elsewhere in the model.
  */
-export interface LightweightDefinition extends HasLocation, HasAnnotation {
+export interface LightweightDefinition extends HasLocation, HasAnnotations {
     type: string;
 }
 interface DocumentReferenceBase {
@@ -436,8 +436,8 @@ export type DocumentReference = DocumentExploreReference | DocumentQueryReferenc
 export interface HasLocation {
     location?: DocumentLocation;
 }
-export interface HasAnnotation {
-    annotation?: Annotation;
+export interface HasAnnotations {
+    annotations?: AnnotationsDef;
 }
 /** All names have their source names and how they will appear in the symbol table that owns them */
 export interface AliasedName {
@@ -497,7 +497,7 @@ export declare function canOrderBy(s: string): boolean;
  * value could be an expression, and this is one of the objects
  * which might have an annotation.
  */
-export interface FieldBase extends NamedObject, Expression, ResultMetadata, HasAnnotation {
+export interface FieldBase extends NamedObject, Expression, ResultMetadata, HasAnnotations {
     accessModifier?: NonDefaultAccessModifierLabel | undefined;
     requiresGroupBy?: RequiredGroupBy[];
     ungroupings?: AggregateUngrouping[];
@@ -659,12 +659,12 @@ export interface TurtleSegment extends Filtered {
 export interface Pipeline {
     pipeline: PipeSegment[];
 }
-export interface Query extends Pipeline, Filtered, HasLocation, HasAnnotation {
+export interface Query extends Pipeline, Filtered, HasLocation, HasAnnotations {
     type?: 'query';
     name?: string;
     structRef: StructRef;
     sourceArguments?: SafeRecord<Argument>;
-    modelAnnotation?: Annotation;
+    modelAnnotations?: AnnotationsDef;
     compositeResolvedSourceDef?: SourceDef;
     givenUsage?: GivenUsage;
 }
@@ -822,7 +822,7 @@ export interface QuerySegment extends Filtered, Ordered, SegmentUsageSummary {
 }
 export type NonDefaultAccessModifierLabel = 'private' | 'internal';
 export type AccessModifierLabel = NonDefaultAccessModifierLabel | 'public';
-export interface TurtleDef extends NamedObject, Pipeline, HasAnnotation {
+export interface TurtleDef extends NamedObject, Pipeline, HasAnnotations {
     type: 'turtle';
     accessModifier?: NonDefaultAccessModifierLabel | undefined;
     refSummary?: RefSummary;
@@ -830,9 +830,9 @@ export interface TurtleDef extends NamedObject, Pipeline, HasAnnotation {
 }
 export interface TurtleDefPlusFilters extends TurtleDef, Filtered {
 }
-interface StructDefBase extends HasLocation, NamedObject, HasAnnotation {
+interface StructDefBase extends HasLocation, NamedObject, HasAnnotations {
     type: string;
-    modelAnnotation?: ModelAnnotation;
+    modelAnnotations?: ModelAnnotationsDef;
     fields: FieldDef[];
     /** Marker for error placeholder structs created by ErrorFactory */
     errorFactory?: boolean;
@@ -1084,7 +1084,7 @@ export type AtomicFieldDef = BasicAtomicDef | BasicArrayDef | RecordDef | Repeat
 export declare function isBasicAtomic(fd: FieldDef | QueryFieldDef | AtomicTypeDef): fd is BasicAtomicDef;
 export type FieldDef = BasicAtomicDef | JoinFieldDef | TurtleDef;
 export type FieldDefType = AtomicFieldType | 'turtle' | JoinElementType;
-export interface RefToField extends HasAnnotation {
+export interface RefToField extends HasAnnotations {
     type: 'fieldref';
     path: string[];
     at?: DocumentLocation;
@@ -1094,11 +1094,11 @@ export type QueryFieldDef = AtomicFieldDef | TurtleDef | RefToField;
 export type TypedDef = AtomicTypeDef | JoinFieldDef | TurtleDef | RefToField | StructDef;
 /** Get the output name for a NamedObject */
 export declare function getIdentifier(n: AliasedName): string;
-export interface UserTypeFieldDef extends HasAnnotation {
+export interface UserTypeFieldDef extends HasAnnotations {
     name: string;
     typeDef: AtomicTypeDef;
 }
-export interface UserTypeDef extends NamedObject, HasAnnotation {
+export interface UserTypeDef extends NamedObject, HasAnnotations {
     type: 'userType';
     fields: UserTypeFieldDef[];
 }
@@ -1120,7 +1120,7 @@ export interface ModelDef {
      */
     sourceRegistry: Record<SourceID, SourceRegistryValue>;
     givens?: Record<GivenID, Given>;
-    annotation?: ModelAnnotation;
+    annotations?: ModelAnnotationsDef;
     queryList: Query[];
     dependencies: DependencyTree;
     references?: DocumentReference[];
@@ -1129,9 +1129,11 @@ export interface ModelDef {
 /** Very common record type */
 export type NamedSourceDefs = SafeRecord<SourceDef>;
 export type NamedModelObjects = SafeRecord<NamedModelObject>;
-/** Malloy source annotations attached to objects */
-export interface Annotation {
-    inherits?: Annotation;
+/** Bundle of source annotations attached to one object: the `notes` and
+ *  `blockNotes` written on it, plus the bundle from the spiritual parent
+ *  via `inherits`. The IR shape paired with the `Annotations` view class. */
+export interface AnnotationsDef {
+    inherits?: AnnotationsDef;
     blockNotes?: Note[];
     notes?: Note[];
 }
@@ -1139,15 +1141,17 @@ export interface Note {
     text: string;
     at: DocumentLocation;
     /**
-     * For block annotations: characters of leading whitespace removed from each
-     * body line by the dedent pass. Used to map payload-parser error columns
-     * back to source (`source_col = indentStripped + parser_col` for body lines).
-     * Omitted for single-line notes and blocks with no common indent.
+     * For multi-line annotations (`#|`…`|#`): characters of leading whitespace
+     * removed from each body line by the dedent pass. Used to map
+     * payload-parser error columns back to source
+     * (`source_col = indentStripped + parser_col` for body lines). Omitted for
+     * single-line annotations and for multi-line annotations with no common
+     * indent.
      */
     indentStripped?: number;
 }
-/** Annotations with a uuid to make it easier to stream */
-export interface ModelAnnotation extends Annotation {
+/** Annotations bundle with a uuid to make it easier to stream. */
+export interface ModelAnnotationsDef extends AnnotationsDef {
     id: string;
 }
 export type QueryScalar = string | boolean | number | bigint | Date | Buffer | null;
@@ -1177,7 +1181,7 @@ export interface DrillSource {
     sourceFilters?: FilterCondition[];
     sourceArguments?: SafeRecord<Argument>;
 }
-export interface CompiledQuery extends DrillSource, HasAnnotation {
+export interface CompiledQuery extends DrillSource, HasAnnotations {
     structs: SourceDef[];
     sql: string;
     lastStageName: string;

package/dist/model/persist_utils.js

@@ -9,7 +9,7 @@ exports.findPersistentDependencies = findPersistentDependencies;
 exports.minimalBuildGraph = minimalBuildGraph;
 const malloy_types_1 = require("./malloy_types");
 const source_def_utils_1 = require("./source_def_utils");
-const annotation_1 = require("../annotation");
+const annotation_1 = require("../api/foundation/annotation");
 /**
  * Resolve a source name to its definition from model contents.
  */
@@ -22,9 +22,9 @@ function resolveSource(modelDef, name) {
  * Returns both the persist flag and any tag parse errors.
  */
 function checkPersistAnnotation(source) {
-    if (!source.annotation)
+    if (!source.annotations)
         return { persist: false, log: [] };
-    const { tag, log } = new annotation_1.Annotations(source.annotation).parseAsTag('@');
+    const { tag, log } = new annotation_1.Annotations(source.annotations).parseAsTag('@');
     return { persist: tag.has('persist'), log };
 }
 /**

package/dist/model/query_model_impl.js

@@ -176,7 +176,7 @@ class QueryModelImpl {
             sourceArguments,
             queryName: query.name,
             connectionName: ret.connectionName,
-            annotation: query.annotation,
+            annotations: query.annotations,
             queryTimezone: ret.structs[0].queryTimezone,
             defaultRowLimitAdded: addedDefaultRowLimit,
         };

package/dist/model/query_node.js

@@ -14,7 +14,7 @@ exports.isBasicScalar = isBasicScalar;
 const uuid_1 = require("uuid");
 const malloy_compile_error_1 = require("./malloy_compile_error");
 const malloy_types_1 = require("./malloy_types");
-const annotation_1 = require("../annotation");
+const annotation_1 = require("../api/foundation/annotation");
 const dialect_1 = require("../dialect");
 const utils_1 = require("./utils");
 class QueryNode {
@@ -205,7 +205,7 @@ class QueryStruct {
     }
     modelCompilerFlags() {
         if (this._modelTag === undefined) {
-            const annotation = this.structDef.modelAnnotation;
+            const annotation = this.structDef.modelAnnotations;
             const { tag } = new annotation_1.Annotations(annotation).parseAsTag('!');
             this._modelTag = tag;
         }
@@ -561,20 +561,20 @@ class QueryStruct {
         return field;
     }
     getQueryFieldReference(f) {
-        const { path, annotation, drillExpression } = f;
+        const { path, annotations, drillExpression } = f;
         const field = this.getFieldByName(path, f.at);
-        if (annotation || drillExpression) {
+        if (annotations || drillExpression) {
             if (field.parent === undefined) {
                 throw new Error('Inconcievable, field reference to orphaned query field');
             }
             // Made a field object from the source, but the annotations were computed by the compiler
             // when it generated the reference, and has both the source and reference annotations included.
             if (field instanceof QueryFieldStruct) {
-                const newDef = { ...field.fieldDef, annotation, drillExpression };
+                const newDef = { ...field.fieldDef, annotations, drillExpression };
                 return new QueryFieldStruct(newDef, undefined, field.parent, field.parent.prepareResultOptions, field.referenceId);
             }
             else {
-                const newDef = { ...field.fieldDef, annotation, drillExpression };
+                const newDef = { ...field.fieldDef, annotations, drillExpression };
                 return field.parent.makeQueryField(newDef, field.referenceId);
             }
         }
@@ -619,7 +619,7 @@ class QueryStruct {
     }
     applyStructFiltersToTurtleDef(turtleDef) {
         const pipeline = [...turtleDef.pipeline];
-        const annotation = turtleDef.annotation;
+        const annotations = turtleDef.annotations;
         const addedFilters = turtleDef.filterList || [];
         pipeline[0] = {
             ...pipeline[0],
@@ -629,7 +629,7 @@ class QueryStruct {
             type: 'turtle',
             name: turtleDef.name,
             pipeline,
-            annotation,
+            annotations,
             location: turtleDef.location,
         };
         return flatTurtleDef;