@malloydata/malloy 0.0.398 → 0.0.400

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -122,6 +122,8 @@ import { ImportStatementContext } from "./MalloyParser";
 import { ImportSelectContext } from "./MalloyParser";
 import { ImportItemContext } from "./MalloyParser";
 import { ImportURLContext } from "./MalloyParser";
+import { ExportStatementContext } from "./MalloyParser";
+import { ExportItemContext } from "./MalloyParser";
 import { DocAnnotationsContext } from "./MalloyParser";
 import { IgnoredObjectAnnotationsContext } from "./MalloyParser";
 import { IgnoredModelAnnotationsContext } from "./MalloyParser";
@@ -1690,6 +1692,26 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitImportURL?: (ctx: ImportURLContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.exportStatement`.
+     * @param ctx the parse tree
+     */
+    enterExportStatement?: (ctx: ExportStatementContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.exportStatement`.
+     * @param ctx the parse tree
+     */
+    exitExportStatement?: (ctx: ExportStatementContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.exportItem`.
+     * @param ctx the parse tree
+     */
+    enterExportItem?: (ctx: ExportItemContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.exportItem`.
+     * @param ctx the parse tree
+     */
+    exitExportItem?: (ctx: ExportItemContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.docAnnotations`.
      * @param ctx the parse tree

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -122,6 +122,8 @@ import { ImportStatementContext } from "./MalloyParser";
 import { ImportSelectContext } from "./MalloyParser";
 import { ImportItemContext } from "./MalloyParser";
 import { ImportURLContext } from "./MalloyParser";
+import { ExportStatementContext } from "./MalloyParser";
+import { ExportItemContext } from "./MalloyParser";
 import { DocAnnotationsContext } from "./MalloyParser";
 import { IgnoredObjectAnnotationsContext } from "./MalloyParser";
 import { IgnoredModelAnnotationsContext } from "./MalloyParser";
@@ -1110,6 +1112,18 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitImportURL?: (ctx: ImportURLContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.exportStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExportStatement?: (ctx: ExportStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.exportItem`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExportItem?: (ctx: ExportItemContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.docAnnotations`.
      * @param ctx the parse tree

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;
@@ -249,6 +249,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitLiteralMonth(pcx: parse.LiteralMonthContext): ast.ExpressionDef;
     visitLiteralQuarter(pcx: parse.LiteralQuarterContext): ast.ExpressionDef;
     visitLiteralYear(pcx: parse.LiteralYearContext): ast.ExpressionDef;
+    visitExportStatement(pcx: parse.ExportStatementContext): ast.ExportStatement;
     visitImportStatement(pcx: parse.ImportStatementContext): ast.ImportStatement;
     visitDebugExpr(pcx: parse.DebugExprContext): ast.ExpressionDef;
     visitSampleStatement(pcx: parse.SampleStatementContext): ast.SampleProperty;
@@ -279,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
@@ -1482,6 +1482,13 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     visitLiteralYear(pcx) {
         return this.parseTime(pcx, ast.LiteralYear.parse);
     }
+    visitExportStatement(pcx) {
+        const items = pcx.exportItem().map(itemCx => {
+            const idCx = itemCx.id();
+            return this.astAt(new ast.ExportItem((0, parse_utils_1.idToStr)(idCx)), idCx);
+        });
+        return this.astAt(new ast.ExportStatement(items), pcx);
+    }
     visitImportStatement(pcx) {
         const url = this.getPlainStringFrom(pcx.importURL());
         const importStmt = this.astAt(new ast.ImportStatement(url, this.parseInfo.importBaseURL), pcx);
@@ -1545,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 => {
@@ -1563,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');
@@ -1576,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-log.d.ts

@@ -281,6 +281,9 @@ type MessageParameterTypes = {
     'selective-import-not-found': string;
     'name-conflict-on-indiscriminate-import': string;
     'failed-import': string;
+    'export-name-not-defined': string;
+    'export-name-not-exportable': string;
+    'duplicate-export-name': string;
     'unsatisfied-given-in-query': string;
     'given-alias-collision': string;
     'failed-to-compute-output-schema': string;

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/filter_compilers.js

@@ -306,7 +306,7 @@ class TemporalFilterCompiler {
         this.qi = queryInfo;
     }
     time(timeSQL) {
-        if (this.timetype === 'timestamp') {
+        if (this.timetype !== 'date') {
             return timeSQL;
         }
         return this.d.sqlCast({}, {

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;

package/dist/model/query_query.js

@@ -403,9 +403,9 @@ class QueryQuery extends query_node_1.QueryField {
                         join: 'many',
                         name,
                         fields: structDef.fields,
-                        ...(structDef.annotation && { annotation: structDef.annotation }),
-                        ...(structDef.modelAnnotation && {
-                            modelAnnotation: structDef.modelAnnotation,
+                        ...(structDef.annotations && { annotations: structDef.annotations }),
+                        ...(structDef.modelAnnotations && {
+                            modelAnnotations: structDef.modelAnnotations,
                         }),
                         resultMetadata,
                         ...(queryTimezone && { queryTimezone }),
@@ -418,9 +418,9 @@ class QueryQuery extends query_node_1.QueryField {
                         join: 'one',
                         name,
                         fields: structDef.fields,
-                        ...(structDef.annotation && { annotation: structDef.annotation }),
-                        ...(structDef.modelAnnotation && {
-                            modelAnnotation: structDef.modelAnnotation,
+                        ...(structDef.annotations && { annotations: structDef.annotations }),
+                        ...(structDef.modelAnnotations && {
+                            modelAnnotations: structDef.modelAnnotations,
                         }),
                         resultMetadata,
                         ...(queryTimezone && { queryTimezone }),
@@ -451,11 +451,11 @@ class QueryQuery extends query_node_1.QueryField {
                         delete fOut.expressionType;
                     }
                     const location = fOut.location;
-                    const annotation = fOut.annotation;
+                    const annotations = fOut.annotations;
                     const common = {
                         resultMetadata,
                         location,
-                        annotation,
+                        annotations,
                     };
                     // build out the result fields...
                     switch (fOut.type) {
@@ -513,8 +513,8 @@ class QueryQuery extends query_node_1.QueryField {
             resultMetadata: this.getResultMetadata(this.rootResult),
             queryTimezone: resultStruct.getQueryInfo().queryTimezone,
         };
-        if (this.parent.structDef.modelAnnotation) {
-            outputStruct.modelAnnotation = this.parent.structDef.modelAnnotation;
+        if (this.parent.structDef.modelAnnotations) {
+            outputStruct.modelAnnotations = this.parent.structDef.modelAnnotations;
         }
         return outputStruct;
     }
@@ -1546,7 +1546,7 @@ class QueryQuery extends query_node_1.QueryField {
             // console.log(stageWriter.generateSQLStages());
             structDef = pipeOut.outputStruct;
         }
-        structDef.annotation = fi.turtleDef.annotation;
+        structDef.annotations = fi.turtleDef.annotations;
         return {
             structDef,
             pipeOut,
@@ -1821,8 +1821,8 @@ class QueryQueryIndex extends QueryQuery {
             ],
             connection: this.parent.connectionName,
         };
-        if (this.parent.structDef.modelAnnotation) {
-            ret.modelAnnotation = this.parent.structDef.modelAnnotation;
+        if (this.parent.structDef.modelAnnotations) {
+            ret.modelAnnotations = this.parent.structDef.modelAnnotations;
         }
         return ret;
     }

package/dist/model/source_def_utils.js

@@ -44,8 +44,8 @@ function mkQuerySourceDef(base, query, name) {
         // HasLocation
         location: base.location,
         // StructDefBase
-        annotation: base.annotation,
-        modelAnnotation: base.modelAnnotation,
+        annotations: base.annotations,
+        modelAnnotations: base.modelAnnotations,
         fields: base.fields,
         // Filtered
         filterList: base.filterList,
@@ -83,8 +83,8 @@ function mkSQLSourceDef(base, selectStr, selectSegments) {
         // HasLocation
         location: base.location,
         // StructDefBase
-        annotation: base.annotation,
-        modelAnnotation: base.modelAnnotation,
+        annotations: base.annotations,
+        modelAnnotations: base.modelAnnotations,
         fields: base.fields,
         // Filtered
         filterList: base.filterList,